home *** CD-ROM | disk | FTP | other *** search
/ Greenhouse Effect Detection Expriment / NASA Greenhouse Effect Detection Expriment 1992 - Disc 2.iso / software / dos / cdf22pc / src / lib / cdf_i_if.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-28  |  79.5 KB  |  3,141 lines
  1. /******************************************************************************
  2. *
  3. *  NSSDC/CDF                CDF INTERNAL interface for FORTRAN.
  4. *
  5. *  Version 1.3, 29-Feb-92, ST Systems (STX)
  6. *
  7. *  Modification history:
  8. *
  9. *   V1.0  30-Jan-91, J Love    Original version (for CDF V2.1).
  10. *   V1.1   6-Aug-91, J Love    Use 'CDFlib'.  If variable is a character data
  11. *                type, check for %DESCR (if VMS).
  12. *   V1.2  24-Oct-91, J Love    Modified for IBM-PC and IBM-RS6000 ports.
  13. *   V1.3  29-Feb-92, J Love    CDF V2.2.
  14. *
  15. ******************************************************************************/
  16.  
  17. #include "cdflib.h"
  18.  
  19. /******************************************************************************
  20. * MACRO to check the status from a call to 'CDFlib'.
  21. ******************************************************************************/
  22.  
  23. #define CHECKstatus(Tstatus,Pstatus) { \
  24. if (Tstatus != CDF_OK) \
  25.   if (Tstatus < CDF_WARN)  /* ERROR */ \
  26.     Pstatus = Tstatus; \
  27.   else \
  28.     if (Tstatus > CDF_OK) {  /* INFO */ \
  29.       if (Pstatus >= CDF_OK) Pstatus = Tstatus; \
  30.     } \
  31.     else  /* WARNING */ \
  32.       Pstatus = Tstatus; \
  33. }
  34.  
  35.  
  36. #if defined(vms)
  37. /******************************************************************************
  38. *
  39. *  Notes (for VMS version):
  40. *
  41. *    To make the user's life a little easier, all names and attribute
  42. *  values (for attributes of data types CDF_CHAR and CDF_UCHAR) may be passed
  43. *  in and out by either reference or descriptor.  The default passing mode
  44. *  for an embedded character string (e.g., CALL subr (..., 'string', ...)) or
  45. *  a CHARACTER variable symbol (e.g., CALL subr (..., ATTR_NAME, ...) where
  46. *  ATTR_NAME is defined as CHARACTER*8) is by descriptor when passing from
  47. *  FORTRAN to C in VMS.
  48. *
  49. *    An embedded character string could be enclosed in %REF() to force
  50. *  passing by reference since the FORTRAN compiler puts a NUL character at
  51. *  the end of these strings as expected by the CDF V2.0 library (written in
  52. *  C).  Enclosing a CHARACTER variable symbol in %REF() will result in
  53. *  an error, however, because a NUL character is not placed at the ends of
  54. *  these type strings by the FORTRAN compiler.  The user would have to
  55. *  supply the terminating NUL.  By letting the passing mode default to by-
  56. *  descriptor, this interface will supply the terminating NUL.
  57. *
  58. *    The main difference here from CDF Version 1 is that the %REF() is
  59. *  not needed when passing out names and attribute values.  Also, %REF()
  60. *  is not necessary when passing the value of a variable that is a character
  61. *  data type.
  62. *
  63. ******************************************************************************/
  64.  
  65. /******************************************************************************
  66. * CDF_lib.  Note that CDFstatus is returned both as an argument (the last
  67. * argument) and as the value of the function.
  68. ******************************************************************************/
  69.  
  70. CDFstatus CDF_lib (va_alist)
  71. va_dcl
  72. {
  73. va_list ap;
  74. CDFstatus Pstatus = CDF_OK;    /* pending status */
  75. CDFstatus Tstatus;        /* temporary status */
  76. CDFstatus *status;        /* address of status variable */
  77. long fnc;            /* function to perform */
  78. long item;            /* item on which to perform a function */
  79.  
  80. CDFid CURid = RESERVED_CDFID;
  81. CDFstatus CURstatus = RESERVED_CDFSTATUS;
  82.  
  83. va_start (ap);
  84.  
  85. fnc = *(va_arg (ap, long *));
  86.  
  87. while (fnc != NULL_)
  88.   switch (fnc) {
  89.     case CREATE_:
  90.       for (;;) {
  91.          item = *(va_arg (ap, long *));
  92.             switch (item) {
  93.        case CDF_: {
  94.           void *CDFname = va_arg (ap, void *);
  95.          long *numDims = va_arg (ap, long *);
  96.          long *dimSizes = va_arg (ap, long *);
  97.          CDFid *id = va_arg (ap, CDFid *);
  98.          if (Pstatus > CDF_WARN) {
  99.            Tstatus = CDFlib (CREATE_, CDF_,
  100.                        DESCRtoREFnul(CDFname,
  101.                                  CDF_PATHNAME_LEN),
  102.                        *numDims, dimSizes, id,
  103.                  NULL_);
  104.            CHECKstatus (Tstatus, Pstatus);
  105.            if (Pstatus > CDF_WARN) CURid = *id;
  106.          }
  107.          break;
  108.        }
  109.        case VAR_: {
  110.          long varNum;
  111.          void *varName = va_arg (ap, void *);
  112.          long *dataType = va_arg (ap, long *);
  113.          long *numElements = va_arg (ap, long *);
  114.          long *recVariance = va_arg (ap, long *);
  115.          long *dimVariances = va_arg (ap, long *);
  116.          long *var_num = va_arg (ap, long *);
  117.          if (Pstatus > CDF_WARN) {
  118.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  119.                  CREATE_, VAR_, DESCRtoREFnul
  120.                            (varName,
  121.                             CDF_VAR_NAME_LEN),
  122.                         *dataType, *numElements,
  123.                         *recVariance,
  124.                         dimVariances, &varNum,
  125.                  NULL_);
  126.            CHECKstatus (Tstatus, Pstatus);
  127.            if (Pstatus > CDF_WARN) *var_num = varNum;
  128.          }
  129.          break;
  130.        }
  131.        case ATTR_: {
  132.          long attrNum;
  133.          void *attrname = va_arg (ap, void *);
  134.          long *scope = va_arg (ap, long *);
  135.              long *attr_num = va_arg (ap, long *);
  136.          if (Pstatus > CDF_WARN) {
  137.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  138.                  CREATE_, ATTR_, DESCRtoREFnul
  139.                            (attrname,
  140.                             CDF_ATTR_NAME_LEN),
  141.                          *scope, &attrNum,
  142.                  NULL_);
  143.            CHECKstatus (Tstatus, Pstatus);
  144.            if (Pstatus > CDF_WARN) *attr_num = attrNum;
  145.          }
  146.          break;
  147.        }
  148.        default: {
  149.          fnc = item;
  150.          break;
  151.        }
  152.      }
  153.      if (fnc == item) break;
  154.       }
  155.       break;
  156.  
  157.     case OPEN_:
  158.       for (;;) {
  159.       item = *(va_arg (ap, long *));
  160.             switch (item) {
  161.        case CDF_: {
  162.          void *CDFname = va_arg (ap, void *);
  163.          CDFid *id = va_arg (ap, CDFid *);
  164.          if (Pstatus > CDF_WARN) {
  165.            Tstatus = CDFlib (OPEN_, CDF_, DESCRtoREFnul
  166.                            (CDFname,
  167.                             CDF_PATHNAME_LEN), id,
  168.                  NULL_);
  169.            CHECKstatus (Tstatus, Pstatus);
  170.            if (Pstatus > CDF_WARN) CURid = *id;
  171.          }
  172.          break;
  173.        }
  174.        default: {
  175.          fnc = item;
  176.          break;
  177.        }
  178.      }
  179.      if (fnc == item) break;
  180.       }
  181.       break;
  182.  
  183.     case DELETE_:
  184.       for (;;) {
  185.          item = *(va_arg (ap, long *));
  186.             switch (item) {
  187.        case CDF_: {
  188.          if (Pstatus > CDF_WARN) {
  189.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  190.                  DELETE_, CDF_,
  191.                  NULL_);
  192.            CHECKstatus (Tstatus, Pstatus);
  193.          }
  194.          break;
  195.        }
  196.        default: {
  197.          fnc = item;
  198.          break;
  199.        }
  200.      }
  201.      if (fnc == item) break;
  202.       }
  203.       break;
  204.  
  205.     case CLOSE_:
  206.       for (;;) {
  207.          item = *(va_arg (ap, long *));
  208.             switch (item) {
  209.        case CDF_: {
  210.          if (Pstatus > CDF_WARN) {
  211.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  212.                  CLOSE_, CDF_,
  213.                  NULL_);
  214.            CHECKstatus (Tstatus, Pstatus);
  215.          }
  216.          break;
  217.        }
  218.        case VAR_: {
  219.          if (Pstatus > CDF_WARN) {
  220.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  221.                  CLOSE_, VAR_,
  222.                  NULL_);
  223.            CHECKstatus (Tstatus, Pstatus);
  224.          }
  225.          break;
  226.        }
  227.        default: {
  228.          fnc = item;
  229.          break;
  230.        }
  231.      }
  232.      if (fnc == item) break;
  233.       }
  234.       break;
  235.  
  236.     case SELECT_:
  237.       for (;;) {
  238.          item = *(va_arg (ap, long *));
  239.             switch (item) {
  240.        case CDF_: {
  241.          CDFid *id = va_arg (ap, CDFid *);
  242.          if (Pstatus > CDF_WARN) {
  243.            Tstatus = CDFlib (SELECT_, CDF_, *id,
  244.                  NULL_);
  245.            CHECKstatus (Tstatus, Pstatus);
  246.            if (Pstatus > CDF_WARN) CURid = *id;
  247.          }
  248.          break;
  249.        }
  250.        case CDF_STATUS_: {
  251.          CDFstatus *status = va_arg (ap, CDFstatus *);
  252.          if (Pstatus > CDF_WARN) {
  253.            Tstatus = CDFlib (SELECT_, CDF_STATUS_, *status,
  254.                  NULL_);
  255.            CHECKstatus (Tstatus, Pstatus);
  256.            if (Pstatus > CDF_WARN) CURstatus = *status;
  257.          }
  258.          break;
  259.        }
  260.        case VAR_: {
  261.          long *var_num = va_arg (ap, long *);
  262.          if (Pstatus > CDF_WARN) {
  263.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  264.                           VAR_, *var_num - 1,
  265.                  NULL_);
  266.            CHECKstatus (Tstatus, Pstatus);
  267.          }
  268.          break;
  269.        }
  270.        case VAR_NAME_: {
  271.          void *varName = va_arg (ap, void *);
  272.          if (Pstatus > CDF_WARN) {
  273.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  274.                           VAR_NAME_,
  275.                         DESCRtoREFnul(varName,
  276.                               CDF_VAR_NAME_LEN),
  277.                  NULL_);
  278.            CHECKstatus (Tstatus, Pstatus);
  279.          }
  280.          break;
  281.        }
  282.        case CDF_RECNUMBER_: {
  283.          long *recnum = va_arg (ap, long *);
  284.          if (Pstatus > CDF_WARN) {
  285.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  286.                           CDF_RECNUMBER_, *recnum - 1,
  287.                  NULL_);
  288.            CHECKstatus (Tstatus, Pstatus);
  289.          }
  290.          break;
  291.        }
  292.        case CDF_RECCOUNT_: {
  293.          long *reccount = va_arg (ap, long *);
  294.          if (Pstatus > CDF_WARN) {
  295.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  296.                           CDF_RECCOUNT_, *reccount,
  297.                  NULL_);
  298.            CHECKstatus (Tstatus, Pstatus);
  299.          }
  300.          break;
  301.        }
  302.        case CDF_RECINTERVAL_: {
  303.          long *recinterval = va_arg (ap, long *);
  304.          if (Pstatus > CDF_WARN) {
  305.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  306.                           CDF_RECINTERVAL_, *recinterval,
  307.                  NULL_);
  308.            CHECKstatus (Tstatus, Pstatus);
  309.          }
  310.          break;
  311.        }
  312.        case CDF_DIMINDICES_: {
  313.          long i;
  314.          long numDims;
  315.          long Cindices[CDF_MAX_DIMS];
  316.          long *indices = va_arg (ap, long *);
  317.          if (Pstatus > CDF_WARN) {
  318.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  319.                  GET_, CDF_NUMDIMS_, &numDims,
  320.                  NULL_);
  321.            CHECKstatus (Tstatus, Pstatus);
  322.            if (Pstatus > CDF_WARN) {
  323.          for (i = 0; i < numDims; i++) Cindices[i] = indices[i] - 1;
  324.              Tstatus = CDFlib (SELECT_, CDF_, CURid,
  325.                             CDF_DIMINDICES_, Cindices,
  326.                    NULL_);
  327.              CHECKstatus (Tstatus, Pstatus);
  328.            }
  329.          }
  330.          break;
  331.        }
  332.        case CDF_DIMCOUNTS_: {
  333.          long *counts = va_arg (ap, long *);
  334.          if (Pstatus > CDF_WARN) {
  335.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  336.                           CDF_DIMCOUNTS_, counts,
  337.                  NULL_);
  338.            CHECKstatus (Tstatus, Pstatus);
  339.          }
  340.          break;
  341.        }
  342.        case CDF_DIMINTERVALS_: {
  343.          long *intervals = va_arg (ap, long *);
  344.          if (Pstatus > CDF_WARN) {
  345.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  346.                           CDF_DIMINTERVALS_, intervals,
  347.                  NULL_);
  348.            CHECKstatus (Tstatus, Pstatus);
  349.          }
  350.          break;
  351.        }
  352.        case VAR_SEQPOS_: {
  353.          long Cindices[CDF_MAX_DIMS];
  354.          long numDims;
  355.          long i;
  356.          long *rec_num = va_arg (ap, long *);
  357.          long *indices = va_arg (ap, long *);
  358.          if (Pstatus > CDF_WARN) {
  359.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  360.                  GET_, CDF_NUMDIMS_, &numDims,
  361.                  NULL_);
  362.            CHECKstatus (Tstatus, Pstatus);
  363.            if (Pstatus > CDF_WARN) {
  364.          for (i = 0; i < numDims; i++) Cindices[i] = indices[i] - 1;
  365.              Tstatus = CDFlib (SELECT_, CDF_, CURid,
  366.                             VAR_SEQPOS_,
  367.                            *rec_num - 1, Cindices,
  368.                    NULL_);
  369.              CHECKstatus (Tstatus, Pstatus);
  370.            }
  371.          }
  372.          break;
  373.        }
  374.        case ATTR_: {
  375.          long *attrnum = va_arg (ap, long *);
  376.          if (Pstatus > CDF_WARN) {
  377.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  378.                           ATTR_, *attrnum - 1,
  379.                  NULL_);
  380.            CHECKstatus (Tstatus, Pstatus);
  381.          }
  382.          break;
  383.        }
  384.        case ATTR_NAME_: {
  385.          void *attrName = va_arg (ap, void *);
  386.          if (Pstatus > CDF_WARN) {
  387.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  388.                           ATTR_NAME_,
  389.                         DESCRtoREFnul(attrName,
  390.                               CDF_ATTR_NAME_LEN),
  391.                  NULL_);
  392.            CHECKstatus (Tstatus, Pstatus);
  393.          }
  394.          break;
  395.        }
  396.        case ENTRY_: {
  397.          long *entrynum = va_arg (ap, long *);
  398.          if (Pstatus > CDF_WARN) {
  399.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  400.                           ENTRY_, *entrynum - 1,
  401.                  NULL_);
  402.            CHECKstatus (Tstatus, Pstatus);
  403.          }
  404.          break;
  405.        }
  406.        default: {
  407.          fnc = item;
  408.          break;
  409.        }
  410.      }
  411.      if (fnc == item) break;
  412.       }
  413.       break;
  414.  
  415.     case CONFIRM_:
  416.       for (;;) {
  417.          item = *(va_arg (ap, long *));
  418.             switch (item) {
  419. #if 0                /* Doesn't make sense to do this anymore. */
  420.        case CDF_: {
  421.          CDFid *id = va_arg (ap, CDFid *);
  422.          if (Pstatus > CDF_WARN) {
  423.            Tstatus = CDFlib (CONFIRM_, CDF_, id,
  424.                  NULL_);
  425.            CHECKstatus (Tstatus, Pstatus);
  426.          }
  427.          break;
  428.        }
  429. #endif
  430. #if 0                /* Doesn't make sense to do this anymore. */
  431.        case CDF_STATUS_: {
  432.          CDFstatus *status = va_arg (ap, CDFstatus *);
  433.          if (Pstatus > CDF_WARN) {
  434.            Tstatus = CDFlib (CONFIRM_, CDF_STATUS_, status,
  435.                  NULL_);
  436.            CHECKstatus (Tstatus, Pstatus);
  437.          }
  438.          break;
  439.        }
  440. #endif
  441.        case CDF_NAME_: {
  442.          char name[CDF_PATHNAME_LEN+1];
  443.          void *cdf_filename = va_arg (ap, void *);
  444.          if (Pstatus > CDF_WARN) {
  445.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  446.                  CONFIRM_, CDF_NAME_, name,
  447.                  NULL_);
  448.            CHECKstatus (Tstatus, Pstatus);
  449.            if (Pstatus > CDF_WARN) CtoFORTstring (name, cdf_filename,
  450.                               CDF_PATHNAME_LEN);
  451.          }
  452.          break;
  453.        }
  454.        case VAR_: {
  455.          long varNum;
  456.          long *var_num = va_arg (ap, long *);
  457.          if (Pstatus > CDF_WARN) {
  458.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  459.                  CONFIRM_, VAR_, &varNum,
  460.                  NULL_);
  461.            CHECKstatus (Tstatus, Pstatus);
  462.            if (Pstatus > CDF_WARN) *var_num = varNum + 1;
  463.          }
  464.          break;
  465.        }
  466.        case CDF_RECNUMBER_: {
  467.          long recNum;
  468.          long *recnum = va_arg (ap, long *);
  469.          if (Pstatus > CDF_WARN) {
  470.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  471.                  CONFIRM_, CDF_RECNUMBER_, &recNum,
  472.                  NULL_);
  473.            CHECKstatus (Tstatus, Pstatus);
  474.            if (Pstatus > CDF_WARN) *recnum = recNum + 1;
  475.          }
  476.          break;
  477.        }
  478.        case CDF_RECCOUNT_: {
  479.          long *reccount = va_arg (ap, long *);
  480.          if (Pstatus > CDF_WARN) {
  481.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  482.                  CONFIRM_, CDF_RECCOUNT_, reccount,
  483.                  NULL_);
  484.            CHECKstatus (Tstatus, Pstatus);
  485.          }
  486.          break;
  487.        }
  488.        case CDF_RECINTERVAL_: {
  489.          long *recinterval = va_arg (ap, long *);
  490.          if (Pstatus > CDF_WARN) {
  491.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  492.                  CONFIRM_, CDF_RECINTERVAL_, recinterval,
  493.                  NULL_);
  494.            CHECKstatus (Tstatus, Pstatus);
  495.          }
  496.          break;
  497.        }
  498.        case CDF_DIMINDICES_: {
  499.          long i;
  500.          long numDims;
  501.          long Cindices[CDF_MAX_DIMS];
  502.          long *indices = va_arg (ap, long *);
  503.          if (Pstatus > CDF_WARN) {
  504.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  505.                  GET_, CDF_NUMDIMS_, &numDims,
  506.                  NULL_);
  507.            CHECKstatus (Tstatus, Pstatus);
  508.            if (Pstatus > CDF_WARN) {
  509.              Tstatus = CDFlib (SELECT_, CDF_, CURid,
  510.                    CONFIRM_, CDF_DIMINDICES_, Cindices,
  511.                    NULL_);
  512.              CHECKstatus (Tstatus, Pstatus);
  513.              if (Pstatus > CDF_WARN) {
  514.            for (i = 0; i < numDims; i++) indices[i] = Cindices[i] + 1;
  515.          }
  516.            }
  517.          }
  518.          break;
  519.        }
  520.        case CDF_DIMCOUNTS_: {
  521.          long *counts = va_arg (ap, long *);
  522.          if (Pstatus > CDF_WARN) {
  523.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  524.                  CONFIRM_, CDF_DIMCOUNTS_, counts,
  525.                  NULL_);
  526.            CHECKstatus (Tstatus, Pstatus);
  527.          }
  528.          break;
  529.        }
  530.        case CDF_DIMINTERVALS_: {
  531.          long *intervals = va_arg (ap, long *);
  532.          if (Pstatus > CDF_WARN) {
  533.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  534.                  CONFIRM_, CDF_DIMINTERVALS_, intervals,
  535.                  NULL_);
  536.            CHECKstatus (Tstatus, Pstatus);
  537.          }
  538.          break;
  539.        }
  540.        case VAR_SEQPOS_: {
  541.          long numDims;
  542.          long recNum;
  543.          long Cindices[CDF_MAX_DIMS];
  544.          long i;
  545.          long *rec_num = va_arg (ap, long *);
  546.          long *indices = va_arg (ap, long *);
  547.          if (Pstatus > CDF_WARN) {
  548.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  549.                  GET_, CDF_NUMDIMS_, &numDims,
  550.                  NULL_);
  551.            CHECKstatus (Tstatus, Pstatus);
  552.            if (Pstatus > CDF_WARN) {
  553.              Tstatus = CDFlib (SELECT_, CDF_, CURid,
  554.                    CONFIRM_, VAR_SEQPOS_,
  555.                         &recNum, Cindices,
  556.                    NULL_);
  557.              CHECKstatus (Tstatus, Pstatus);
  558.              if (Pstatus > CDF_WARN) {
  559.            *rec_num = recNum + 1;
  560.            for (i = 0; i < numDims; i++) indices[i] = Cindices[i] + 1;
  561.          }
  562.            }
  563.          }
  564.          break;
  565.        }
  566.        case ATTR_: {
  567.          long attrNum;
  568.          long *attr_num = va_arg (ap, long *);
  569.          if (Pstatus > CDF_WARN) {
  570.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  571.                  CONFIRM_, ATTR_, &attrNum,
  572.                  NULL_);
  573.            CHECKstatus (Tstatus, Pstatus);
  574.            if (Pstatus > CDF_WARN) *attr_num = attrNum + 1;
  575.          }
  576.          break;
  577.        }
  578.        case ENTRY_: {
  579.          long entryNum;
  580.          long *entry_num = va_arg (ap, long *);
  581.          if (Pstatus > CDF_WARN) {
  582.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  583.                  CONFIRM_, ENTRY_, &entryNum,
  584.                  NULL_);
  585.            CHECKstatus (Tstatus, Pstatus);
  586.            if (Pstatus > CDF_WARN) *entry_num = entryNum + 1;
  587.          }
  588.          break;
  589.        }
  590.        default: {
  591.          fnc = item;
  592.          break;
  593.        }
  594.      }
  595.      if (fnc == item) break;
  596.       }
  597.       break;
  598.  
  599.     case GET_:
  600.       for (;;) {
  601.          item = *(va_arg (ap, long *));
  602.             switch (item) {
  603.        case CDF_NUMDIMS_: {
  604.          long *numDims = va_arg (ap, long *);
  605.          if (Pstatus > CDF_WARN) {
  606.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  607.                  GET_, CDF_NUMDIMS_, numDims,
  608.                  NULL_);
  609.            CHECKstatus (Tstatus, Pstatus);
  610.          }
  611.          break;
  612.        }
  613.        case CDF_DIMSIZES_: {
  614.          long *dimsize = va_arg (ap, long *);
  615.          if (Pstatus > CDF_WARN) {
  616.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  617.                  GET_, CDF_DIMSIZES_, dimsize,
  618.                  NULL_);
  619.            CHECKstatus (Tstatus, Pstatus);
  620.          }
  621.          break;
  622.        }
  623.        case CDF_ENCODING_: {
  624.          long *encoding = va_arg (ap, long *);
  625.          if (Pstatus > CDF_WARN) {
  626.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  627.                  GET_, CDF_ENCODING_, encoding,
  628.                  NULL_);
  629.            CHECKstatus (Tstatus, Pstatus);
  630.          }
  631.          break;
  632.        }
  633.        case CDF_MAJORITY_: {
  634.          long *majority = va_arg (ap, long *);
  635.          if (Pstatus > CDF_WARN) {
  636.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  637.                  GET_, CDF_MAJORITY_, majority,
  638.                  NULL_);
  639.            CHECKstatus (Tstatus, Pstatus);
  640.          }
  641.          break;
  642.        }
  643.        case CDF_FORMAT_: {
  644.          long *format = va_arg (ap, long *);
  645.          if (Pstatus > CDF_WARN) {
  646.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  647.                  GET_, CDF_FORMAT_, format,
  648.                  NULL_);
  649.            CHECKstatus (Tstatus, Pstatus);
  650.          }
  651.          break;
  652.        }
  653.        case CDF_COPYRIGHT_: {
  654.          char text[CDF_DOCUMENT_LEN+1];
  655.          void *copyRight = va_arg (ap, void *);
  656.          if (Pstatus > CDF_WARN) {
  657.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  658.                  GET_, CDF_COPYRIGHT_, text,
  659.                  NULL_);
  660.            CHECKstatus (Tstatus, Pstatus);
  661.            if (Pstatus > CDF_WARN) CtoFORTstring (text, copyRight,
  662.                               CDF_DOCUMENT_LEN);
  663.          }
  664.          break;
  665.        }
  666.        case LIB_COPYRIGHT_: {
  667.          char text[CDF_DOCUMENT_LEN+1];
  668.          void *copyRight = va_arg (ap, void *);
  669.          if (Pstatus > CDF_WARN) {
  670.            Tstatus = CDFlib (GET_, LIB_COPYRIGHT_, text,
  671.                  NULL_);
  672.            CHECKstatus (Tstatus, Pstatus);
  673.            if (Pstatus > CDF_WARN) CtoFORTstring (text, copyRight,
  674.                               CDF_DOCUMENT_LEN);
  675.          }
  676.          break;
  677.        }
  678.        case CDF_NUMVARS_: {
  679.          long *numvars = va_arg (ap, long *);
  680.          if (Pstatus > CDF_WARN) {
  681.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  682.                  GET_, CDF_NUMVARS_, numvars,
  683.                  NULL_);
  684.            CHECKstatus (Tstatus, Pstatus);
  685.          }
  686.          break;
  687.        }
  688.        case CDF_NUMATTRS_: {
  689.          long *numattr = va_arg (ap, long *);
  690.          if (Pstatus > CDF_WARN) {
  691.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  692.                  GET_, CDF_NUMATTRS_, numattr,
  693.                  NULL_);
  694.            CHECKstatus (Tstatus, Pstatus);
  695.          }
  696.          break;
  697.        }
  698.        case CDF_MAXREC_: {
  699.          long maxRec;
  700.          long *max_rec = va_arg (ap, long *);
  701.          if (Pstatus > CDF_WARN) {
  702.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  703.                  GET_, CDF_MAXREC_, &maxRec,
  704.                  NULL_);
  705.            CHECKstatus (Tstatus, Pstatus);
  706.            if (Pstatus > CDF_WARN) *max_rec = maxRec + 1;
  707.          }
  708.          break;
  709.        }
  710.        case CDF_VERSION_: {
  711.          long *version = va_arg (ap, long *);
  712.          if (Pstatus > CDF_WARN) {
  713.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  714.                  GET_, CDF_VERSION_, version,
  715.                  NULL_);
  716.            CHECKstatus (Tstatus, Pstatus);
  717.          }
  718.          break;
  719.        }
  720.        case CDF_RELEASE_: {
  721.          long *release = va_arg (ap, long *);
  722.          if (Pstatus > CDF_WARN) {
  723.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  724.                  GET_, CDF_RELEASE_, release,
  725.                  NULL_);
  726.            CHECKstatus (Tstatus, Pstatus);
  727.          }
  728.          break;
  729.        }
  730.        case CDF_INCREMENT_: {
  731.          long *increment = va_arg (ap, long *);
  732.          if (Pstatus > CDF_WARN) {
  733.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  734.                  GET_, CDF_INCREMENT_, increment,
  735.                  NULL_);
  736.            CHECKstatus (Tstatus, Pstatus);
  737.          }
  738.          break;
  739.        }
  740.        case LIB_VERSION_: {
  741.          long *version = va_arg (ap, long *);
  742.          if (Pstatus > CDF_WARN) {
  743.            Tstatus = CDFlib (GET_, LIB_VERSION_, version,
  744.                  NULL_);
  745.            CHECKstatus (Tstatus, Pstatus);
  746.          }
  747.          break;
  748.        }
  749.        case LIB_RELEASE_: {
  750.          long *release = va_arg (ap, long *);
  751.          if (Pstatus > CDF_WARN) {
  752.            Tstatus = CDFlib (GET_, LIB_RELEASE_, release,
  753.                  NULL_);
  754.            CHECKstatus (Tstatus, Pstatus);
  755.          }
  756.          break;
  757.        }
  758.        case LIB_INCREMENT_: {
  759.          long *increment = va_arg (ap, long *);
  760.          if (Pstatus > CDF_WARN) {
  761.            Tstatus = CDFlib (GET_, LIB_INCREMENT_, increment,
  762.                  NULL_);
  763.            CHECKstatus (Tstatus, Pstatus);
  764.          }
  765.          break;
  766.        }
  767.        case LIB_subINCREMENT_: {
  768.          char subIncr;
  769.          void *subincrement = va_arg (ap, void *);
  770.          if (Pstatus > CDF_WARN) {
  771.            Tstatus = CDFlib (GET_, LIB_subINCREMENT_, &subIncr,
  772.                  NULL_);
  773.            CHECKstatus (Tstatus, Pstatus);
  774.            if (Pstatus > CDF_WARN) CtoFORTstring (&subIncr,
  775.                               subincrement, 1);
  776.          }
  777.          break;
  778.        }
  779.        case VAR_NAME_: {
  780.          char varName[CDF_VAR_NAME_LEN+1];
  781.          void *name = va_arg (ap, void *);
  782.          if (Pstatus > CDF_WARN) {
  783.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  784.                  GET_, VAR_NAME_, varName,
  785.                  NULL_);
  786.            CHECKstatus (Tstatus, Pstatus);
  787.            if (Pstatus > CDF_WARN) CtoFORTstring (varName, name,
  788.                               CDF_VAR_NAME_LEN);
  789.          }
  790.          break;
  791.        }
  792.        case VAR_DATATYPE_: {
  793.          long *datatype = va_arg (ap, long *);
  794.          if (Pstatus > CDF_WARN) {
  795.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  796.                  GET_, VAR_DATATYPE_, datatype,
  797.                  NULL_);
  798.            CHECKstatus (Tstatus, Pstatus);
  799.          }
  800.          break;
  801.        }
  802.        case VAR_NUMELEMS_: {
  803.          long *numElements = va_arg (ap, long *);
  804.          if (Pstatus > CDF_WARN) {
  805.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  806.                  GET_, VAR_NUMELEMS_, numElements,
  807.                  NULL_);
  808.            CHECKstatus (Tstatus, Pstatus);
  809.          }
  810.          break;
  811.        }
  812.        case VAR_RECVARY_: {
  813.          long *recvary = va_arg (ap, long *);
  814.          if (Pstatus > CDF_WARN) {
  815.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  816.                  GET_, VAR_RECVARY_, recvary,
  817.                  NULL_);
  818.            CHECKstatus (Tstatus, Pstatus);
  819.          }
  820.          break;
  821.        }
  822.        case VAR_DIMVARYS_: {
  823.          long *dimVarys = va_arg (ap, long *);
  824.          if (Pstatus > CDF_WARN) {
  825.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  826.                  GET_, VAR_DIMVARYS_, dimVarys,
  827.                  NULL_);
  828.            CHECKstatus (Tstatus, Pstatus);
  829.          }
  830.          break;
  831.        }
  832.        case VAR_MAXREC_: {
  833.          long varMaxRec;
  834.          long *var_max_rec = va_arg (ap, long *);
  835.          if (Pstatus > CDF_WARN) {
  836.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  837.                  GET_, VAR_MAXREC_, &varMaxRec,
  838.                  NULL_);
  839.            CHECKstatus (Tstatus, Pstatus);
  840.            if (Pstatus > CDF_WARN) *var_max_rec = varMaxRec + 1;
  841.          }
  842.          break;
  843.        }
  844.        case VAR_NUMBER_: {
  845.          long varNum;
  846.          void *name = va_arg (ap, void *);
  847.          long *varnum = va_arg (ap, long *);
  848.          if (Pstatus > CDF_WARN) {
  849.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  850.                  GET_, VAR_NUMBER_, DESCRtoREFnul
  851.                            (name,
  852.                             CDF_VAR_NAME_LEN),
  853.                         &varNum,
  854.                  NULL_);
  855.            CHECKstatus (Tstatus, Pstatus);
  856.            if (Pstatus > CDF_WARN) *varnum = varNum + 1;
  857.          }
  858.          break;
  859.        }
  860.        case VAR_EXTENDRECS_: {
  861.          long *NextendRecs = va_arg (ap, long *);
  862.          if (Pstatus > CDF_WARN) {
  863.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  864.                  GET_, VAR_EXTENDRECS_, NextendRecs,
  865.                  NULL_);
  866.            CHECKstatus (Tstatus, Pstatus);
  867.          }
  868.          break;
  869.        }
  870.        case VAR_FILLVALUE_: {
  871.          long dataType;
  872.          void *fillValue = va_arg (ap, void *);
  873.          if (Pstatus > CDF_WARN) {
  874.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  875.                  GET_, VAR_DATATYPE_, &dataType,
  876.                  NULL_);
  877.            CHECKstatus (Tstatus, Pstatus);
  878.            if (Pstatus > CDF_WARN) {
  879.              Tstatus = CDFlib (SELECT_, CDF_, CURid,
  880.                    GET_, VAR_FILLVALUE_,
  881.                       STRINGdataType(dataType) ?
  882.                          DESCRtoREF(fillValue) : fillValue,
  883.                    NULL_);
  884.              CHECKstatus (Tstatus, Pstatus);
  885.            }
  886.          }
  887.          break;
  888.        }
  889.        case VAR_DATA_: {
  890.          long dataType;
  891.          void *value = va_arg (ap, void *);
  892.          if (Pstatus > CDF_WARN) {
  893.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  894.                  GET_, VAR_DATATYPE_, &dataType,
  895.                  NULL_);
  896.            CHECKstatus (Tstatus, Pstatus);
  897.            if (Pstatus > CDF_WARN) {
  898.              Tstatus = CDFlib (SELECT_, CDF_, CURid,
  899.                    GET_, VAR_DATA_,
  900.                         STRINGdataType(dataType) ?
  901.                                 DESCRtoREF(value) : value,
  902.                    NULL_);
  903.              CHECKstatus (Tstatus, Pstatus);
  904.            }
  905.          }
  906.          break;
  907.        }
  908.        case VAR_HYPERDATA_: {
  909.          long dataType;
  910.          void *buffer = va_arg (ap, void *);
  911.          if (Pstatus > CDF_WARN) {
  912.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  913.                  GET_, VAR_DATATYPE_, &dataType,
  914.                  NULL_);
  915.            CHECKstatus (Tstatus, Pstatus);
  916.            if (Pstatus > CDF_WARN) {
  917.              Tstatus = CDFlib (SELECT_, CDF_, CURid,
  918.                    GET_, VAR_HYPERDATA_,
  919.                         STRINGdataType(dataType) ?
  920.                                DESCRtoREF(buffer) : buffer,
  921.                    NULL_);
  922.              CHECKstatus (Tstatus, Pstatus);
  923.            }
  924.          }
  925.          break;
  926.        }
  927.        case VAR_SEQDATA_: {
  928.          long dataType;
  929.          void *value = va_arg (ap, void *);
  930.          if (Pstatus > CDF_WARN) {
  931.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  932.                  GET_, VAR_DATATYPE_, &dataType,
  933.                  NULL_);
  934.            CHECKstatus (Tstatus, Pstatus);
  935.            if (Pstatus > CDF_WARN) {
  936.              Tstatus = CDFlib (SELECT_, CDF_, CURid,
  937.                    GET_, VAR_SEQDATA_,
  938.                         STRINGdataType(dataType) ?
  939.                                 DESCRtoREF(value) : value,
  940.                    NULL_);
  941.              CHECKstatus (Tstatus, Pstatus);
  942.            }
  943.          }
  944.          break;
  945.        }
  946.        case ATTR_SCOPE_: {
  947.          long *scope = va_arg (ap, long *);
  948.          if (Pstatus > CDF_WARN) {
  949.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  950.                  GET_, ATTR_SCOPE_, scope,
  951.                  NULL_);
  952.            CHECKstatus (Tstatus, Pstatus);
  953.          }
  954.          break;
  955.        }
  956.        case ATTR_NAME_: {
  957.          char name[CDF_ATTR_NAME_LEN+1];
  958.          void *attrname = va_arg (ap, void *);
  959.          if (Pstatus > CDF_WARN) {
  960.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  961.                  GET_, ATTR_NAME_, name,
  962.                  NULL_);
  963.            CHECKstatus (Tstatus, Pstatus);
  964.            if (Pstatus > CDF_WARN) CtoFORTstring (name, attrname,
  965.                               CDF_ATTR_NAME_LEN);
  966.          }
  967.          break;
  968.        }
  969.        case ATTR_NUMBER_: {
  970.          long attrNum;
  971.          void *name = va_arg (ap, void *);
  972.          long *attrnum = va_arg (ap, long *);
  973.          if (Pstatus > CDF_WARN) {
  974.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  975.                  GET_, ATTR_NUMBER_, DESCRtoREFnul
  976.                            (name,
  977.                             CDF_ATTR_NAME_LEN),
  978.                          &attrNum,
  979.                  NULL_);
  980.            CHECKstatus (Tstatus, Pstatus);
  981.            if (Pstatus > CDF_WARN) *attrnum = attrNum + 1;
  982.          }
  983.          break;
  984.        }
  985.        case ATTR_MAXENTRY_: {
  986.          long maxEntry;
  987.          long *max_entry = va_arg (ap, long *);
  988.          if (Pstatus > CDF_WARN) {
  989.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  990.                  GET_, ATTR_MAXENTRY_, &maxEntry,
  991.                  NULL_);
  992.            CHECKstatus (Tstatus, Pstatus);
  993.            if (Pstatus > CDF_WARN) *max_entry = maxEntry + 1;
  994.          }
  995.          break;
  996.        }
  997.        case ATTR_NUMENTRIES_: {
  998.          long *numEntries = va_arg (ap, long *);
  999.          if (Pstatus > CDF_WARN) {
  1000.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  1001.                  GET_, ATTR_NUMENTRIES_, numEntries,
  1002.                  NULL_);
  1003.            CHECKstatus (Tstatus, Pstatus);
  1004.          }
  1005.          break;
  1006.        }
  1007.        case ENTRY_DATATYPE_: {
  1008.          long *datatype = va_arg (ap, long *);
  1009.          if (Pstatus > CDF_WARN) {
  1010.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  1011.                  GET_, ENTRY_DATATYPE_, datatype,
  1012.                  NULL_);
  1013.            CHECKstatus (Tstatus, Pstatus);
  1014.          }
  1015.          break;
  1016.        }
  1017.        case ENTRY_NUMELEMS_: {
  1018.          long *numelem = va_arg (ap, long *);
  1019.          if (Pstatus > CDF_WARN) {
  1020.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  1021.                  GET_, ENTRY_NUMELEMS_, numelem,
  1022.                  NULL_);
  1023.            CHECKstatus (Tstatus, Pstatus);
  1024.          }
  1025.          break;
  1026.        }
  1027.        case ENTRY_DATA_: {
  1028.          long dataType;
  1029.          void *value = va_arg (ap, void *);
  1030.          if (Pstatus > CDF_WARN) {
  1031.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  1032.                  GET_, ENTRY_DATATYPE_, &dataType,
  1033.                  NULL_);
  1034.            CHECKstatus (Tstatus, Pstatus);
  1035.            if (Pstatus > CDF_WARN) {
  1036.              Tstatus = CDFlib (SELECT_, CDF_, CURid,
  1037.                    GET_, ENTRY_DATA_,
  1038.                         STRINGdataType(dataType) ?
  1039.                            DESCRtoREF(value) : value,
  1040.                    NULL_);
  1041.              CHECKstatus (Tstatus, Pstatus);
  1042.            }
  1043.          }
  1044.          break;
  1045.        }
  1046.        case STATUS_TEXT_: {
  1047.          char text[CDF_STATUSTEXT_LEN+1];
  1048.          void *textPtr = va_arg (ap, void *);
  1049.          if (Pstatus > CDF_WARN) {
  1050.            Tstatus = CDFlib (SELECT_, CDF_STATUS_, CURstatus,
  1051.                  GET_, STATUS_TEXT_, text,
  1052.                  NULL_);
  1053.            CHECKstatus (Tstatus, Pstatus);
  1054.            if (Pstatus > CDF_WARN) CtoFORTstring (text, textPtr,
  1055.                               CDF_STATUSTEXT_LEN);
  1056.          }
  1057.          break;
  1058.        }
  1059.        default: {
  1060.          fnc = item;
  1061.          break;
  1062.        }
  1063.      }
  1064.      if (fnc == item) break;
  1065.       }
  1066.       break;
  1067.  
  1068.     case PUT_:
  1069.       for (;;) {
  1070.          item = *(va_arg (ap, long *));
  1071.             switch (item) {
  1072.        case CDF_ARRAY_: {
  1073.          long *numDims = va_arg (ap, long *);
  1074.          long *dimSizes = va_arg (ap, long *);
  1075.          if (Pstatus > CDF_WARN) {
  1076.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  1077.                  PUT_, CDF_ARRAY_, *numDims, dimSizes,
  1078.                  NULL_);
  1079.            CHECKstatus (Tstatus, Pstatus);
  1080.          }
  1081.          break;
  1082.        }
  1083.        case CDF_ENCODING_: {
  1084.          long *encoding = va_arg (ap, long *);
  1085.          if (Pstatus > CDF_WARN) {
  1086.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  1087.                  PUT_, CDF_ENCODING_, *encoding,
  1088.                  NULL_);
  1089.            CHECKstatus (Tstatus, Pstatus);
  1090.          }
  1091.          break;
  1092.        }
  1093.        case CDF_MAJORITY_: {
  1094.          long *majority = va_arg (ap, long *);
  1095.          if (Pstatus > CDF_WARN) {
  1096.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  1097.                  PUT_, CDF_MAJORITY_, *majority,
  1098.                  NULL_);
  1099.            CHECKstatus (Tstatus, Pstatus);
  1100.          }
  1101.          break;
  1102.        }
  1103.        case CDF_FORMAT_: {
  1104.          long *format = va_arg (ap, long *);
  1105.          if (Pstatus > CDF_WARN) {
  1106.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  1107.                  PUT_, CDF_FORMAT_, *format,
  1108.                  NULL_);
  1109.            CHECKstatus (Tstatus, Pstatus);
  1110.          }
  1111.          break;
  1112.        }
  1113.        case VAR_NAME_: {
  1114.          void *varName = va_arg (ap, void *);
  1115.          if (Pstatus > CDF_WARN) {
  1116.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  1117.                  PUT_, VAR_NAME_, DESCRtoREFnul
  1118.                            (varName,
  1119.                             CDF_VAR_NAME_LEN),
  1120.                  NULL_);
  1121.            CHECKstatus (Tstatus, Pstatus);
  1122.          }
  1123.          break;
  1124.        }
  1125.        case VAR_DATASPEC_: {
  1126.          long *dataType = va_arg (ap, long *);
  1127.          long *numElements = va_arg (ap, long *);
  1128.          if (Pstatus > CDF_WARN) {
  1129.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  1130.                  PUT_, VAR_DATASPEC_, *dataType,
  1131.                              *numElements,
  1132.                  NULL_);
  1133.            CHECKstatus (Tstatus, Pstatus);
  1134.          }
  1135.          break;
  1136.        }
  1137.        case VAR_RECVARY_: {
  1138.          long *recVariance = va_arg (ap, long *);
  1139.          if (Pstatus > CDF_WARN) {
  1140.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  1141.                  PUT_, VAR_RECVARY_, *recVariance,
  1142.                  NULL_);
  1143.            CHECKstatus (Tstatus, Pstatus);
  1144.          }
  1145.          break;
  1146.        }
  1147.        case VAR_DIMVARYS_: {
  1148.          long *dimVarys = va_arg (ap, long *);
  1149.          if (Pstatus > CDF_WARN) {
  1150.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  1151.                  PUT_, VAR_DIMVARYS_, dimVarys,
  1152.                  NULL_);
  1153.            CHECKstatus (Tstatus, Pstatus);
  1154.          }
  1155.          break;
  1156.        }
  1157.        case VAR_INITIALRECS_: {
  1158.          long *NinitialRecs = va_arg (ap, long *);
  1159.          if (Pstatus > CDF_WARN) {
  1160.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  1161.                  PUT_, VAR_INITIALRECS_, *NinitialRecs,
  1162.                  NULL_);
  1163.            CHECKstatus (Tstatus, Pstatus);
  1164.          }
  1165.          break;
  1166.        }
  1167.        case VAR_EXTENDRECS_: {
  1168.          long *NextendRecs = va_arg (ap, long *);
  1169.          if (Pstatus > CDF_WARN) {
  1170.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  1171.                  PUT_, VAR_EXTENDRECS_, *NextendRecs,
  1172.                  NULL_);
  1173.            CHECKstatus (Tstatus, Pstatus);
  1174.          }
  1175.          break;
  1176.        }
  1177.        case VAR_FILLVALUE_: {
  1178.          long dataType;
  1179.          void *fillValue = va_arg (ap, void *);
  1180.          if (Pstatus > CDF_WARN) {
  1181.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  1182.                  GET_, VAR_DATATYPE_, &dataType,
  1183.                  NULL_);
  1184.            CHECKstatus (Tstatus, Pstatus);
  1185.            if (Pstatus > CDF_WARN) {
  1186.              Tstatus = CDFlib (SELECT_, CDF_, CURid,
  1187.                    PUT_, VAR_FILLVALUE_,
  1188.                       STRINGdataType(dataType) ?
  1189.                          DESCRtoREF(fillValue) : fillValue,
  1190.                    NULL_);
  1191.              CHECKstatus (Tstatus, Pstatus);
  1192.            }
  1193.          }
  1194.          break;
  1195.        }
  1196.        case VAR_DATA_: {
  1197.          long dataType;
  1198.          void *value = va_arg (ap, void *);
  1199.          if (Pstatus > CDF_WARN) {
  1200.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  1201.                  GET_, VAR_DATATYPE_, &dataType,
  1202.                  NULL_);
  1203.            CHECKstatus (Tstatus, Pstatus);
  1204.            if (Pstatus > CDF_WARN) {
  1205.              Tstatus = CDFlib (SELECT_, CDF_, CURid,
  1206.                    PUT_, VAR_DATA_,
  1207.                         STRINGdataType(dataType) ?
  1208.                                 DESCRtoREF(value) : value,
  1209.                    NULL_);
  1210.              CHECKstatus (Tstatus, Pstatus);
  1211.            }
  1212.          }
  1213.          break;
  1214.        }
  1215.        case VAR_HYPERDATA_: {
  1216.          long dataType;
  1217.          void *buffer = va_arg (ap, void *);
  1218.          if (Pstatus > CDF_WARN) {
  1219.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  1220.                  GET_, VAR_DATATYPE_, &dataType,
  1221.                  NULL_);
  1222.            CHECKstatus (Tstatus, Pstatus);
  1223.            if (Pstatus > CDF_WARN) {
  1224.              Tstatus = CDFlib (SELECT_, CDF_, CURid,
  1225.                    PUT_, VAR_HYPERDATA_,
  1226.                         STRINGdataType(dataType) ?
  1227.                                DESCRtoREF(buffer) : buffer,
  1228.                    NULL_);
  1229.              CHECKstatus (Tstatus, Pstatus);
  1230.            }
  1231.          }
  1232.          break;
  1233.        }
  1234.        case VAR_SEQDATA_: {
  1235.          long dataType;
  1236.          void *value = va_arg (ap, void *);
  1237.          if (Pstatus > CDF_WARN) {
  1238.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  1239.                  GET_, VAR_DATATYPE_, &dataType,
  1240.                  NULL_);
  1241.            CHECKstatus (Tstatus, Pstatus);
  1242.            if (Pstatus > CDF_WARN) {
  1243.              Tstatus = CDFlib (SELECT_, CDF_, CURid,
  1244.                    PUT_, VAR_SEQDATA_,
  1245.                         STRINGdataType(dataType) ?
  1246.                                 DESCRtoREF(value) : value,
  1247.                    NULL_);
  1248.              CHECKstatus (Tstatus, Pstatus);
  1249.            }
  1250.          }
  1251.          break;
  1252.        }
  1253.        case ATTR_SCOPE_: {
  1254.          long *scope = va_arg (ap, long *);
  1255.          if (Pstatus > CDF_WARN) {
  1256.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  1257.                  PUT_, ATTR_SCOPE_, *scope,
  1258.                  NULL_);
  1259.            CHECKstatus (Tstatus, Pstatus);
  1260.          }
  1261.          break;
  1262.        }
  1263.        case ATTR_NAME_: {
  1264.          void *attrname = va_arg (ap, void *);
  1265.          if (Pstatus > CDF_WARN) {
  1266.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  1267.                  PUT_, ATTR_NAME_, DESCRtoREFnul
  1268.                            (attrname,
  1269.                             CDF_ATTR_NAME_LEN),
  1270.                  NULL_);
  1271.            CHECKstatus (Tstatus, Pstatus);
  1272.          }
  1273.          break;
  1274.        }
  1275.        case ENTRY_DATA_: {
  1276.          long *dataType = va_arg (ap, long *);
  1277.          long *numElements = va_arg (ap, long *);
  1278.          void *value = va_arg (ap, void *);
  1279.          if (Pstatus > CDF_WARN) {
  1280.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  1281.                  PUT_, ENTRY_DATA_, *dataType, *numElements,
  1282.                            STRINGdataType(*dataType) ?
  1283.                            DESCRtoREF(value) : value,
  1284.                  NULL_);
  1285.            CHECKstatus (Tstatus, Pstatus);
  1286.          }
  1287.          break;
  1288.        }
  1289.        default: {
  1290.          fnc = item;
  1291.          break;
  1292.        }
  1293.      }
  1294.      if (fnc == item) break;
  1295.       }
  1296.       break;
  1297.  
  1298.     default: {
  1299.       va_end (ap);
  1300.       return BAD_FNC_OR_ITEM;
  1301.     }
  1302.   }
  1303.  
  1304. status = va_arg (ap, long *);
  1305. *status = Pstatus;
  1306.  
  1307. va_end (ap);
  1308.  
  1309. return Pstatus;
  1310. }
  1311. #endif
  1312.  
  1313.  
  1314. #if defined(unix)
  1315. /******************************************************************************
  1316. *
  1317. *  Notes (for UNIX version):
  1318. *
  1319. *    All passing between FORTRAN and C on UNIX systems is done by reference.
  1320. *  When character strings are passed between FORTRAN and C, extra arguments
  1321. *  are added to the argument list containing the lengths of those character
  1322. *  strings.
  1323. *
  1324. *    Entry points have been made lowercase because the FORTRAN compiler
  1325. *  converts all uppercase characters to lowercase in entry points.  This way
  1326. *  the linker will find everything.  Unix FORTRAN compilers and linkers also
  1327. *  seem to like trailing '_'s (except on the IBM-RS6000/AIX).
  1328. *
  1329. ******************************************************************************/
  1330.  
  1331. /******************************************************************************
  1332. * CDF_lib.  Note that CDFstatus is returned both as an argument (the last
  1333. * argument) and as the value of the function.
  1334. ******************************************************************************/
  1335.  
  1336. #if defined(AIX)
  1337. CDFstatus cdf_lib (va_alist)
  1338. #else
  1339. CDFstatus cdf_lib_ (va_alist)
  1340. #endif
  1341. va_dcl
  1342. {
  1343. va_list ap;
  1344. CDFstatus Pstatus = CDF_OK;    /* pending status */
  1345. CDFstatus Tstatus;        /* temporary status */
  1346. CDFstatus *status;        /* address of status variable */
  1347. long fnc;            /* function to perform */
  1348. long item;            /* item on which to perform a function */
  1349. long i;
  1350. long stringCount = 0;
  1351. long *stringLengths;        /* lengths of (possible) character strings
  1352.                    passed in - some arguments may or may not
  1353.                    be character strings (eg. var. data) */
  1354.  
  1355. CDFid CURid = RESERVED_CDFID;
  1356. CDFstatus CURstatus = RESERVED_CDFSTATUS;
  1357.  
  1358. /******************************************************************************
  1359. * Scan argument list counting number of (possible) strings passed in.
  1360. ******************************************************************************/
  1361.  
  1362. va_start (ap);
  1363.  
  1364. fnc = *(va_arg (ap, long *));
  1365.  
  1366. while (fnc != NULL_)
  1367.   switch (fnc) {
  1368.     case CREATE_:
  1369.       for (;;) {
  1370.          item = *(va_arg (ap, long *));
  1371.             switch (item) {
  1372.        case CDF_: {
  1373.           char *CDFname = va_arg (ap, char *);
  1374.          long *numDims = va_arg (ap, long *);
  1375.          long *dimSizes = va_arg (ap, long *);
  1376.          CDFid *id = va_arg (ap, CDFid *);
  1377.          stringCount++;
  1378.          break;
  1379.        }
  1380.        case VAR_: {
  1381.          char *varName = va_arg (ap, char *);
  1382.          long *dataType = va_arg (ap, long *);
  1383.          long *numElements = va_arg (ap, long *);
  1384.          long *recVariance = va_arg (ap, long *);
  1385.          long *dimVariances = va_arg (ap, long *);
  1386.          long *var_num = va_arg (ap, long *);
  1387.          stringCount++;
  1388.          break;
  1389.        }
  1390.        case ATTR_: {
  1391.          char *attrname = va_arg (ap, char *);
  1392.          long *scope = va_arg (ap, long *);
  1393.              long *attr_num = va_arg (ap, long *);
  1394.          stringCount++;
  1395.          break;
  1396.        }
  1397.        default: {
  1398.          fnc = item;
  1399.          break;
  1400.        }
  1401.      }
  1402.      if (fnc == item) break;
  1403.       }
  1404.       break;
  1405.  
  1406.     case OPEN_:
  1407.       for (;;) {
  1408.       item = *(va_arg (ap, long *));
  1409.             switch (item) {
  1410.        case CDF_: {
  1411.          char *CDFname = va_arg (ap, char *);
  1412.          CDFid *id = va_arg (ap, CDFid *);
  1413.          stringCount++;
  1414.          break;
  1415.        }
  1416.        default: {
  1417.          fnc = item;
  1418.          break;
  1419.        }
  1420.      }
  1421.      if (fnc == item) break;
  1422.       }
  1423.       break;
  1424.  
  1425.     case DELETE_:
  1426.       for (;;) {
  1427.          item = *(va_arg (ap, long *));
  1428.             switch (item) {
  1429.        case CDF_: {
  1430.          break;
  1431.        }
  1432.        default: {
  1433.          fnc = item;
  1434.          break;
  1435.        }
  1436.      }
  1437.      if (fnc == item) break;
  1438.       }
  1439.       break;
  1440.  
  1441.     case CLOSE_:
  1442.       for (;;) {
  1443.          item = *(va_arg (ap, long *));
  1444.             switch (item) {
  1445.        case CDF_: {
  1446.          break;
  1447.        }
  1448.        case VAR_: {
  1449.          break;
  1450.        }
  1451.        default: {
  1452.          fnc = item;
  1453.          break;
  1454.        }
  1455.      }
  1456.      if (fnc == item) break;
  1457.       }
  1458.       break;
  1459.  
  1460.     case SELECT_:
  1461.       for (;;) {
  1462.          item = *(va_arg (ap, long *));
  1463.             switch (item) {
  1464.        case CDF_: {
  1465.          CDFid *id = va_arg (ap, CDFid *);
  1466.          break;
  1467.        }
  1468.        case CDF_STATUS_: {
  1469.          CDFstatus *status = va_arg (ap, CDFstatus *);
  1470.          break;
  1471.        }
  1472.        case VAR_: {
  1473.          long *var_num = va_arg (ap, long *);
  1474.          break;
  1475.        }
  1476.        case VAR_NAME_: {
  1477.          char *varName = va_arg (ap, char *);
  1478.          stringCount++;
  1479.          break;
  1480.        }
  1481.        case CDF_RECNUMBER_: {
  1482.          long *recnum = va_arg (ap, long *);
  1483.          break;
  1484.        }
  1485.        case CDF_RECCOUNT_: {
  1486.          long *reccount = va_arg (ap, long *);
  1487.          break;
  1488.        }
  1489.        case CDF_RECINTERVAL_: {
  1490.          long *recinterval = va_arg (ap, long *);
  1491.          break;
  1492.        }
  1493.        case CDF_DIMINDICES_: {
  1494.          long *indices = va_arg (ap, long *);
  1495.          break;
  1496.        }
  1497.        case CDF_DIMCOUNTS_: {
  1498.          long *counts = va_arg (ap, long *);
  1499.          break;
  1500.        }
  1501.        case CDF_DIMINTERVALS_: {
  1502.          long *intervals = va_arg (ap, long *);
  1503.          break;
  1504.        }
  1505.        case VAR_SEQPOS_: {
  1506.          long *rec_num = va_arg (ap, long *);
  1507.          long *indices = va_arg (ap, long *);
  1508.          break;
  1509.        }
  1510.        case ATTR_: {
  1511.          long *attrnum = va_arg (ap, long *);
  1512.          break;
  1513.        }
  1514.        case ATTR_NAME_: {
  1515.          char *attrName = va_arg (ap, char *);
  1516.          stringCount++;
  1517.          break;
  1518.        }
  1519.        case ENTRY_: {
  1520.          long *entrynum = va_arg (ap, long *);
  1521.          break;
  1522.        }
  1523.        default: {
  1524.          fnc = item;
  1525.          break;
  1526.        }
  1527.      }
  1528.      if (fnc == item) break;
  1529.       }
  1530.       break;
  1531.  
  1532.     case CONFIRM_:
  1533.       for (;;) {
  1534.          item = *(va_arg (ap, long *));
  1535.             switch (item) {
  1536.        case CDF_: {
  1537.          CDFid *id = va_arg (ap, CDFid *);
  1538.          break;
  1539.        }
  1540.        case CDF_STATUS_: {
  1541.          CDFstatus *status = va_arg (ap, CDFstatus *);
  1542.          break;
  1543.        }
  1544.        case CDF_NAME_: {
  1545.          char *cdf_filename = va_arg (ap, char *);
  1546.          stringCount++;
  1547.          break;
  1548.        }
  1549.        case VAR_: {
  1550.          long *var_num = va_arg (ap, long *);
  1551.          break;
  1552.        }
  1553.        case CDF_RECNUMBER_: {
  1554.          long *recnum = va_arg (ap, long *);
  1555.          break;
  1556.        }
  1557.        case CDF_RECCOUNT_: {
  1558.          long *reccount = va_arg (ap, long *);
  1559.          break;
  1560.        }
  1561.        case CDF_RECINTERVAL_: {
  1562.          long *recinterval = va_arg (ap, long *);
  1563.          break;
  1564.        }
  1565.        case CDF_DIMINDICES_: {
  1566.          long *indices = va_arg (ap, long *);
  1567.          break;
  1568.        }
  1569.        case CDF_DIMCOUNTS_: {
  1570.          long *counts = va_arg (ap, long *);
  1571.          break;
  1572.        }
  1573.        case CDF_DIMINTERVALS_: {
  1574.          long *intervals = va_arg (ap, long *);
  1575.          break;
  1576.        }
  1577.        case VAR_SEQPOS_: {
  1578.          long *rec_num = va_arg (ap, long *);
  1579.          long *indices = va_arg (ap, long *);
  1580.          break;
  1581.        }
  1582.        case ATTR_: {
  1583.          long *attr_num = va_arg (ap, long *);
  1584.          break;
  1585.        }
  1586.        case ENTRY_: {
  1587.          long *entry_num = va_arg (ap, long *);
  1588.          break;
  1589.        }
  1590.        default: {
  1591.          fnc = item;
  1592.          break;
  1593.        }
  1594.      }
  1595.      if (fnc == item) break;
  1596.       }
  1597.       break;
  1598.  
  1599.     case GET_:
  1600.       for (;;) {
  1601.          item = *(va_arg (ap, long *));
  1602.             switch (item) {
  1603.        case CDF_NUMDIMS_: {
  1604.          long *numDims = va_arg (ap, long *);
  1605.          break;
  1606.        }
  1607.        case CDF_DIMSIZES_: {
  1608.          long *dimsize = va_arg (ap, long *);
  1609.          break;
  1610.        }
  1611.        case CDF_ENCODING_: {
  1612.          long *encoding = va_arg (ap, long *);
  1613.          break;
  1614.        }
  1615.        case CDF_MAJORITY_: {
  1616.          long *majority = va_arg (ap, long *);
  1617.          break;
  1618.        }
  1619.        case CDF_FORMAT_: {
  1620.          long *format = va_arg (ap, long *);
  1621.          break;
  1622.        }
  1623.        case CDF_COPYRIGHT_: {
  1624.          char *copyRight = va_arg (ap, char *);
  1625.          stringCount++;
  1626.          break;
  1627.        }
  1628.        case LIB_COPYRIGHT_: {
  1629.          char *copyRight = va_arg (ap, char *);
  1630.          stringCount++;
  1631.          break;
  1632.        }
  1633.        case CDF_NUMVARS_: {
  1634.          long *numvars = va_arg (ap, long *);
  1635.          break;
  1636.        }
  1637.        case CDF_NUMATTRS_: {
  1638.          long *numattr = va_arg (ap, long *);
  1639.          break;
  1640.        }
  1641.        case CDF_MAXREC_: {
  1642.          long *max_rec = va_arg (ap, long *);
  1643.          break;
  1644.        }
  1645.        case CDF_VERSION_: {
  1646.          long *version = va_arg (ap, long *);
  1647.          break;
  1648.        }
  1649.        case CDF_RELEASE_: {
  1650.          long *release = va_arg (ap, long *);
  1651.          break;
  1652.        }
  1653.        case CDF_INCREMENT_: {
  1654.          long *increment = va_arg (ap, long *);
  1655.          break;
  1656.        }
  1657.        case LIB_VERSION_: {
  1658.          long *version = va_arg (ap, long *);
  1659.          break;
  1660.        }
  1661.        case LIB_RELEASE_: {
  1662.          long *release = va_arg (ap, long *);
  1663.          break;
  1664.        }
  1665.        case LIB_INCREMENT_: {
  1666.          long *increment = va_arg (ap, long *);
  1667.          break;
  1668.        }
  1669.        case LIB_subINCREMENT_: {
  1670.          char *subincrement = va_arg (ap, char *);
  1671.          stringCount++;
  1672.          break;
  1673.        }
  1674.        case VAR_NAME_: {
  1675.          char *name = va_arg (ap, char *);
  1676.          stringCount++;
  1677.          break;
  1678.        }
  1679.        case VAR_DATATYPE_: {
  1680.          long *datatype = va_arg (ap, long *);
  1681.          break;
  1682.        }
  1683.        case VAR_NUMELEMS_: {
  1684.          long *numElements = va_arg (ap, long *);
  1685.          break;
  1686.        }
  1687.        case VAR_RECVARY_: {
  1688.          long *recvary = va_arg (ap, long *);
  1689.          break;
  1690.        }
  1691.        case VAR_DIMVARYS_: {
  1692.          long *dimVarys = va_arg (ap, long *);
  1693.          break;
  1694.        }
  1695.        case VAR_MAXREC_: {
  1696.          long *var_max_rec = va_arg (ap, long *);
  1697.          break;
  1698.        }
  1699.        case VAR_NUMBER_: {
  1700.          char *name = va_arg (ap, char *);
  1701.          long *varnum = va_arg (ap, long *);
  1702.          stringCount++;
  1703.          break;
  1704.        }
  1705.        case VAR_EXTENDRECS_: {
  1706.          long *NextendRecs = va_arg (ap, long *);
  1707.          break;
  1708.        }
  1709.        case VAR_FILLVALUE_: {
  1710.          void *fillValue = va_arg (ap, void *);
  1711.          stringCount++;
  1712.          break;
  1713.        }
  1714.        case VAR_DATA_: {
  1715.          void *value = va_arg (ap, void *);
  1716.          stringCount++;
  1717.          break;
  1718.        }
  1719.        case VAR_HYPERDATA_: {
  1720.          void *buffer = va_arg (ap, void *);
  1721.          stringCount++;
  1722.          break;
  1723.        }
  1724.        case VAR_SEQDATA_: {
  1725.          void *value = va_arg (ap, void *);
  1726.          stringCount++;
  1727.          break;
  1728.        }
  1729.        case ATTR_SCOPE_: {
  1730.          long *scope = va_arg (ap, long *);
  1731.          break;
  1732.        }
  1733.        case ATTR_NAME_: {
  1734.          char *attrname = va_arg (ap, char *);
  1735.          stringCount++;
  1736.          break;
  1737.        }
  1738.        case ATTR_NUMBER_: {
  1739.          char *name = va_arg (ap, void *);
  1740.          long *attrnum = va_arg (ap, long *);
  1741.          stringCount++;
  1742.          break;
  1743.        }
  1744.        case ATTR_MAXENTRY_: {
  1745.          long *max_entry = va_arg (ap, long *);
  1746.          break;
  1747.        }
  1748.        case ATTR_NUMENTRIES_: {
  1749.          long *numEntries = va_arg (ap, long *);
  1750.          break;
  1751.        }
  1752.        case ENTRY_DATATYPE_: {
  1753.          long *datatype = va_arg (ap, long *);
  1754.          break;
  1755.        }
  1756.        case ENTRY_NUMELEMS_: {
  1757.          long *numelem = va_arg (ap, long *);
  1758.          break;
  1759.        }
  1760.        case ENTRY_DATA_: {
  1761.          void *value = va_arg (ap, void *);
  1762.          stringCount++;
  1763.          break;
  1764.        }
  1765.        case STATUS_TEXT_: {
  1766.          char *textPtr = va_arg (ap, void *);
  1767.          stringCount++;
  1768.          break;
  1769.        }
  1770.        default: {
  1771.          fnc = item;
  1772.          break;
  1773.        }
  1774.      }
  1775.      if (fnc == item) break;
  1776.       }
  1777.       break;
  1778.  
  1779.     case PUT_:
  1780.       for (;;) {
  1781.          item = *(va_arg (ap, long *));
  1782.             switch (item) {
  1783.        case CDF_ARRAY_: {
  1784.          long *numDims = va_arg (ap, long *);
  1785.          long *dimSizes = va_arg (ap, long *);
  1786.          break;
  1787.        }
  1788.        case CDF_ENCODING_: {
  1789.          long *encoding = va_arg (ap, long *);
  1790.          break;
  1791.        }
  1792.        case CDF_MAJORITY_: {
  1793.          long *majority = va_arg (ap, long *);
  1794.          break;
  1795.        }
  1796.        case CDF_FORMAT_: {
  1797.          long *format = va_arg (ap, long *);
  1798.          break;
  1799.        }
  1800.        case VAR_NAME_: {
  1801.          char *varName = va_arg (ap, char *);
  1802.          stringCount++;
  1803.          break;
  1804.        }
  1805.        case VAR_DATASPEC_: {
  1806.          long *dataType = va_arg (ap, long *);
  1807.          long *numElements = va_arg (ap, long *);
  1808.          break;
  1809.        }
  1810.        case VAR_RECVARY_: {
  1811.          long *recVariance = va_arg (ap, long *);
  1812.          break;
  1813.        }
  1814.        case VAR_DIMVARYS_: {
  1815.          long *dimVarys = va_arg (ap, long *);
  1816.          break;
  1817.        }
  1818.        case VAR_INITIALRECS_: {
  1819.          long *NinitialRecs = va_arg (ap, long *);
  1820.          break;
  1821.        }
  1822.        case VAR_EXTENDRECS_: {
  1823.          long *NextendRecs = va_arg (ap, long *);
  1824.          break;
  1825.        }
  1826.        case VAR_FILLVALUE_: {
  1827.          void *value = va_arg (ap, void *);
  1828.          stringCount++;
  1829.          break;
  1830.        }
  1831.        case VAR_DATA_: {
  1832.          void *value = va_arg (ap, void *);
  1833.          stringCount++;
  1834.          break;
  1835.        }
  1836.        case VAR_HYPERDATA_: {
  1837.          void *buffer = va_arg (ap, void *);
  1838.          stringCount++;
  1839.          break;
  1840.        }
  1841.        case VAR_SEQDATA_: {
  1842.          void *value = va_arg (ap, void *);
  1843.          stringCount++;
  1844.          break;
  1845.        }
  1846.        case ATTR_SCOPE_: {
  1847.          long *scope = va_arg (ap, long *);
  1848.          break;
  1849.        }
  1850.        case ATTR_NAME_: {
  1851.          char *attrname = va_arg (ap, char *);
  1852.          stringCount++;
  1853.          break;
  1854.        }
  1855.        case ENTRY_DATA_: {
  1856.          long *dataType = va_arg (ap, long *);
  1857.          long *numElements = va_arg (ap, long *);
  1858.          void *value = va_arg (ap, void *);
  1859.          stringCount++;
  1860.          break;
  1861.        }
  1862.        default: {
  1863.          fnc = item;
  1864.          break;
  1865.        }
  1866.      }
  1867.      if (fnc == item) break;
  1868.       }
  1869.       break;
  1870.  
  1871.     default: {
  1872.       va_end (ap);
  1873.       return BAD_FNC_OR_ITEM;
  1874.     }
  1875.   }
  1876.  
  1877. status = va_arg (ap, long *);
  1878.  
  1879. /******************************************************************************
  1880. * Store character strings lengths.
  1881. ******************************************************************************/
  1882.  
  1883. if (stringCount > 0) {
  1884.   stringLengths = (long *) malloc (stringCount * sizeof(long));
  1885.   if (stringLengths == NULL) {
  1886.     *status = BAD_MALLOC;
  1887.     return BAD_MALLOC;
  1888.   }
  1889.   for (i = 0; i < stringCount; i++) stringLengths[i] = va_arg (ap, long);
  1890. }
  1891. else
  1892.   stringLengths = NULL;
  1893.  
  1894. va_end (ap);
  1895.  
  1896. /******************************************************************************
  1897. * Scan argument list again performing functions.
  1898. ******************************************************************************/
  1899.  
  1900. stringCount = 0;        /* start at beginning of list of string lengths */
  1901.  
  1902. va_start (ap);
  1903.  
  1904. fnc = *(va_arg (ap, long *));
  1905.  
  1906. while (fnc != NULL_)
  1907.   switch (fnc) {
  1908.     case CREATE_:
  1909.       for (;;) {
  1910.          item = *(va_arg (ap, long *));
  1911.             switch (item) {
  1912.        case CDF_: {
  1913.           char *CDFname = va_arg (ap, char *);
  1914.          long *numDims = va_arg (ap, long *);
  1915.          long *dimSizes = va_arg (ap, long *);
  1916.          CDFid *id = va_arg (ap, CDFid *);
  1917.          if (Pstatus > CDF_WARN) {
  1918.            Tstatus = CDFlib (CREATE_,
  1919.                    CDF_, NULterminate
  1920.                         (CDFname,
  1921.                          stringLengths[stringCount]),
  1922.                      *numDims, dimSizes, id,
  1923.                  NULL_);
  1924.            CHECKstatus (Tstatus, Pstatus);
  1925.            if (Pstatus > CDF_WARN) {
  1926.          stringCount++;
  1927.          CURid = *id;
  1928.            }
  1929.          }
  1930.          break;
  1931.        }
  1932.        case VAR_: {
  1933.          long varNum;
  1934.          char *varName = va_arg (ap, char *);
  1935.          long *dataType = va_arg (ap, long *);
  1936.          long *numElements = va_arg (ap, long *);
  1937.          long *recVariance = va_arg (ap, long *);
  1938.          long *dimVariances = va_arg (ap, long *);
  1939.          long *var_num = va_arg (ap, long *);
  1940.          if (Pstatus > CDF_WARN) {
  1941.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  1942.                  CREATE_,
  1943.                     VAR_, NULterminate
  1944.                         (varName,
  1945.                          stringLengths[stringCount]),
  1946.                       *dataType, *numElements,
  1947.                       *recVariance,
  1948.                       dimVariances, &varNum,
  1949.                  NULL_);
  1950.            CHECKstatus (Tstatus, Pstatus);
  1951.            if (Pstatus > CDF_WARN) {
  1952.          *var_num = varNum;
  1953.          stringCount++;
  1954.            }
  1955.          }
  1956.          break;
  1957.        }
  1958.        case ATTR_: {
  1959.          long attrNum;
  1960.          char *attrname = va_arg (ap, char *);
  1961.          long *scope = va_arg (ap, long *);
  1962.              long *attr_num = va_arg (ap, long *);
  1963.          if (Pstatus > CDF_WARN) {
  1964.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  1965.                  CREATE_,
  1966.                    ATTR_, NULterminate
  1967.                         (attrname,
  1968.                          stringLengths[stringCount]),
  1969.                       *scope, &attrNum,
  1970.                  NULL_);
  1971.            CHECKstatus (Tstatus, Pstatus);
  1972.            if (Pstatus > CDF_WARN) {
  1973.          *attr_num = attrNum;
  1974.          stringCount++;
  1975.            }
  1976.          }
  1977.          break;
  1978.        }
  1979.        default: {
  1980.          fnc = item;
  1981.          break;
  1982.        }
  1983.      }
  1984.      if (fnc == item) break;
  1985.       }
  1986.       break;
  1987.  
  1988.     case OPEN_:
  1989.       for (;;) {
  1990.       item = *(va_arg (ap, long *));
  1991.             switch (item) {
  1992.        case CDF_: {
  1993.          char *CDFname = va_arg (ap, char *);
  1994.          CDFid *id = va_arg (ap, CDFid *);
  1995.          if (Pstatus > CDF_WARN) {
  1996.            Tstatus = CDFlib (OPEN_, CDF_,
  1997.                        NULterminate
  1998.                          (CDFname,
  1999.                           stringLengths[stringCount]),
  2000.                        id,
  2001.                  NULL_);
  2002.            CHECKstatus (Tstatus, Pstatus);
  2003.            if (Pstatus > CDF_WARN) {
  2004.          stringCount++;
  2005.          CURid = *id;
  2006.            }
  2007.          }
  2008.          break;
  2009.        }
  2010.        default: {
  2011.          fnc = item;
  2012.          break;
  2013.        }
  2014.      }
  2015.      if (fnc == item) break;
  2016.       }
  2017.       break;
  2018.  
  2019.     case DELETE_:
  2020.       for (;;) {
  2021.          item = *(va_arg (ap, long *));
  2022.             switch (item) {
  2023.        case CDF_: {
  2024.          if (Pstatus > CDF_WARN) {
  2025.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2026.                  DELETE_, CDF_,
  2027.                  NULL_);
  2028.            CHECKstatus (Tstatus, Pstatus);
  2029.          }
  2030.          break;
  2031.        }
  2032.        default: {
  2033.          fnc = item;
  2034.          break;
  2035.        }
  2036.      }
  2037.      if (fnc == item) break;
  2038.       }
  2039.       break;
  2040.  
  2041.     case CLOSE_:
  2042.       for (;;) {
  2043.          item = *(va_arg (ap, long *));
  2044.             switch (item) {
  2045.        case CDF_: {
  2046.          if (Pstatus > CDF_WARN) {
  2047.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2048.                  CLOSE_, CDF_,
  2049.                  NULL_);
  2050.            CHECKstatus (Tstatus, Pstatus);
  2051.          }
  2052.          break;
  2053.        }
  2054.        case VAR_: {
  2055.          if (Pstatus > CDF_WARN) {
  2056.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2057.                  CLOSE_, VAR_,
  2058.                  NULL_);
  2059.            CHECKstatus (Tstatus, Pstatus);
  2060.          }
  2061.          break;
  2062.        }
  2063.        default: {
  2064.          fnc = item;
  2065.          break;
  2066.        }
  2067.      }
  2068.      if (fnc == item) break;
  2069.       }
  2070.       break;
  2071.  
  2072.     case SELECT_:
  2073.       for (;;) {
  2074.          item = *(va_arg (ap, long *));
  2075.             switch (item) {
  2076.        case CDF_: {
  2077.          CDFid *id = va_arg (ap, CDFid *);
  2078.          if (Pstatus > CDF_WARN) {
  2079.            Tstatus = CDFlib (SELECT_, CDF_, *id,
  2080.                  NULL_);
  2081.            CHECKstatus (Tstatus, Pstatus);
  2082.            if (Pstatus > CDF_WARN) CURid = *id;
  2083.          }
  2084.          break;
  2085.        }
  2086.        case CDF_STATUS_: {
  2087.          CDFstatus *status = va_arg (ap, CDFstatus *);
  2088.          if (Pstatus > CDF_WARN) {
  2089.            Tstatus = CDFlib (SELECT_, CDF_STATUS_, *status,
  2090.                  NULL_);
  2091.            CHECKstatus (Tstatus, Pstatus);
  2092.            if (Pstatus > CDF_WARN) CURstatus = *status;
  2093.          }
  2094.          break;
  2095.        }
  2096.        case VAR_: {
  2097.          long *var_num = va_arg (ap, long *);
  2098.          if (Pstatus > CDF_WARN) {
  2099.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2100.                       VAR_, *var_num - 1,
  2101.                  NULL_);
  2102.            CHECKstatus (Tstatus, Pstatus);
  2103.          }
  2104.          break;
  2105.        }
  2106.        case VAR_NAME_: {
  2107.          char *varName = va_arg (ap, char *);
  2108.          if (Pstatus > CDF_WARN) {
  2109.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2110.                       VAR_NAME_,
  2111.                         NULterminate
  2112.                         (varName,
  2113.                          stringLengths[stringCount]),
  2114.                  NULL_);
  2115.            CHECKstatus (Tstatus, Pstatus);
  2116.            if (Pstatus > CDF_WARN) stringCount++;
  2117.          }
  2118.          break;
  2119.        }
  2120.        case CDF_RECNUMBER_: {
  2121.          long *recnum = va_arg (ap, long *);
  2122.          if (Pstatus > CDF_WARN) {
  2123.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2124.                       CDF_RECNUMBER_, *recnum - 1,
  2125.                  NULL_);
  2126.            CHECKstatus (Tstatus, Pstatus);
  2127.          }
  2128.          break;
  2129.        }
  2130.        case CDF_RECCOUNT_: {
  2131.          long *reccount = va_arg (ap, long *);
  2132.          if (Pstatus > CDF_WARN) {
  2133.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2134.                       CDF_RECCOUNT_, *reccount,
  2135.                  NULL_);
  2136.            CHECKstatus (Tstatus, Pstatus);
  2137.          }
  2138.          break;
  2139.        }
  2140.        case CDF_RECINTERVAL_: {
  2141.          long *recinterval = va_arg (ap, long *);
  2142.          if (Pstatus > CDF_WARN) {
  2143.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2144.                       CDF_RECINTERVAL_, *recinterval,
  2145.                  NULL_);
  2146.            CHECKstatus (Tstatus, Pstatus);
  2147.          }
  2148.          break;
  2149.        }
  2150.        case CDF_DIMINDICES_: {
  2151.          long i;
  2152.          long numDims;
  2153.          long Cindices[CDF_MAX_DIMS];
  2154.          long *indices = va_arg (ap, long *);
  2155.          if (Pstatus > CDF_WARN) {
  2156.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2157.                  GET_, CDF_NUMDIMS_, &numDims,
  2158.                  NULL_);
  2159.            CHECKstatus (Tstatus, Pstatus);
  2160.            if (Pstatus > CDF_WARN) {
  2161.          for (i = 0; i < numDims; i++) Cindices[i] = indices[i] - 1;
  2162.              Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2163.                         CDF_DIMINDICES_, Cindices,
  2164.                    NULL_);
  2165.              CHECKstatus (Tstatus, Pstatus);
  2166.            }
  2167.          }
  2168.          break;
  2169.        }
  2170.        case CDF_DIMCOUNTS_: {
  2171.          long *counts = va_arg (ap, long *);
  2172.          if (Pstatus > CDF_WARN) {
  2173.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2174.                       CDF_DIMCOUNTS_, counts,
  2175.                  NULL_);
  2176.            CHECKstatus (Tstatus, Pstatus);
  2177.          }
  2178.          break;
  2179.        }
  2180.        case CDF_DIMINTERVALS_: {
  2181.          long *intervals = va_arg (ap, long *);
  2182.          if (Pstatus > CDF_WARN) {
  2183.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2184.                       CDF_DIMINTERVALS_, intervals,
  2185.                  NULL_);
  2186.            CHECKstatus (Tstatus, Pstatus);
  2187.          }
  2188.          break;
  2189.        }
  2190.        case VAR_SEQPOS_: {
  2191.          long numDims;
  2192.          long Cindices[CDF_MAX_DIMS];
  2193.          long *rec_num = va_arg (ap, long *);
  2194.          long *indices = va_arg (ap, long *);
  2195.          long i;
  2196.          if (Pstatus > CDF_WARN) {
  2197.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2198.                  GET_, CDF_NUMDIMS_, &numDims,
  2199.                  NULL_);
  2200.            CHECKstatus (Tstatus, Pstatus);
  2201.            if (Pstatus > CDF_WARN) {
  2202.          for (i = 0; i < numDims; i++) Cindices[i] = indices[i] - 1;
  2203.              Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2204.                         VAR_SEQPOS_,
  2205.                            *rec_num - 1, Cindices,
  2206.                    NULL_);
  2207.              CHECKstatus (Tstatus, Pstatus);
  2208.            }
  2209.          }
  2210.          break;
  2211.        }
  2212.        case ATTR_: {
  2213.          long *attrnum = va_arg (ap, long *);
  2214.          if (Pstatus > CDF_WARN) {
  2215.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2216.                       ATTR_, *attrnum - 1,
  2217.                  NULL_);
  2218.            CHECKstatus (Tstatus, Pstatus);
  2219.          }
  2220.          break;
  2221.        }
  2222.        case ATTR_NAME_: {
  2223.          char *attrName = va_arg (ap, char *);
  2224.          if (Pstatus > CDF_WARN) {
  2225.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2226.                       ATTR_NAME_,
  2227.                         NULterminate
  2228.                         (attrName,
  2229.                          stringLengths[stringCount]),
  2230.                  NULL_);
  2231.            CHECKstatus (Tstatus, Pstatus);
  2232.            if (Pstatus > CDF_WARN) stringCount++;
  2233.          }
  2234.          break;
  2235.        }
  2236.        case ENTRY_: {
  2237.          long *entrynum = va_arg (ap, long *);
  2238.          if (Pstatus > CDF_WARN) {
  2239.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2240.                       ENTRY_, *entrynum - 1,
  2241.                  NULL_);
  2242.            CHECKstatus (Tstatus, Pstatus);
  2243.          }
  2244.          break;
  2245.        }
  2246.        default: {
  2247.          fnc = item;
  2248.          break;
  2249.        }
  2250.      }
  2251.      if (fnc == item) break;
  2252.       }
  2253.       break;
  2254.  
  2255.     case CONFIRM_:
  2256.       for (;;) {
  2257.          item = *(va_arg (ap, long *));
  2258.             switch (item) {
  2259. #if 0                /* Doesn't make sense to do this anymore. */
  2260.        case CDF_: {
  2261.          CDFid *id = va_arg (ap, CDFid *);
  2262.          if (Pstatus > CDF_WARN) {
  2263.            Tstatus = CDFlib (CONFIRM_, CDF_, id,
  2264.                  NULL_);
  2265.            CHECKstatus (Tstatus, Pstatus);
  2266.          }
  2267.          break;
  2268.        }
  2269. #endif
  2270. #if 0                /* Doesn't make sense to do this anymore. */
  2271.        case CDF_STATUS_: {
  2272.          CDFstatus *status = va_arg (ap, CDFstatus *);
  2273.          if (Pstatus > CDF_WARN) {
  2274.            Tstatus = CDFlib (CONFIRM_, CDF_STATUS_, status,
  2275.                  NULL_);
  2276.            CHECKstatus (Tstatus, Pstatus);
  2277.          }
  2278.          break;
  2279.        }
  2280. #endif
  2281.        case CDF_NAME_: {
  2282.          char name[CDF_PATHNAME_LEN+1];
  2283.          char *cdf_filename = va_arg (ap, char *);
  2284.          if (Pstatus > CDF_WARN) {
  2285.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2286.                  CONFIRM_, CDF_NAME_, name,
  2287.                  NULL_);
  2288.            CHECKstatus (Tstatus, Pstatus);
  2289.            if (Pstatus > CDF_WARN) {
  2290.          CtoFORTstring (name, cdf_filename,
  2291.                 stringLengths[stringCount]);
  2292.          stringCount++;
  2293.            }
  2294.          }
  2295.          break;
  2296.        }
  2297.        case VAR_: {
  2298.          long varNum;
  2299.          long *var_num = va_arg (ap, long *);
  2300.          if (Pstatus > CDF_WARN) {
  2301.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2302.                  CONFIRM_, VAR_, &varNum,
  2303.                  NULL_);
  2304.            CHECKstatus (Tstatus, Pstatus);
  2305.            if (Pstatus > CDF_WARN) *var_num = varNum + 1;
  2306.          }
  2307.          break;
  2308.        }
  2309.        case CDF_RECNUMBER_: {
  2310.          long recNum;
  2311.          long *recnum = va_arg (ap, long *);
  2312.          if (Pstatus > CDF_WARN) {
  2313.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2314.                  CONFIRM_, CDF_RECNUMBER_, &recNum,
  2315.                  NULL_);
  2316.            CHECKstatus (Tstatus, Pstatus);
  2317.            if (Pstatus > CDF_WARN) *recnum = recNum + 1;
  2318.          }
  2319.          break;
  2320.        }
  2321.        case CDF_RECCOUNT_: {
  2322.          long *reccount = va_arg (ap, long *);
  2323.          if (Pstatus > CDF_WARN) {
  2324.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2325.                  CONFIRM_, CDF_RECCOUNT_, reccount,
  2326.                  NULL_);
  2327.            CHECKstatus (Tstatus, Pstatus);
  2328.          }
  2329.          break;
  2330.        }
  2331.        case CDF_RECINTERVAL_: {
  2332.          long *recinterval = va_arg (ap, long *);
  2333.          if (Pstatus > CDF_WARN) {
  2334.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2335.                  CONFIRM_, CDF_RECINTERVAL_, recinterval,
  2336.                  NULL_);
  2337.            CHECKstatus (Tstatus, Pstatus);
  2338.          }
  2339.          break;
  2340.        }
  2341.        case CDF_DIMINDICES_: {
  2342.          long i;
  2343.          long numDims;
  2344.          long Cindices[CDF_MAX_DIMS];
  2345.          long *indices = va_arg (ap, long *);
  2346.          if (Pstatus > CDF_WARN) {
  2347.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2348.                  GET_, CDF_NUMDIMS_, &numDims,
  2349.                  NULL_);
  2350.            CHECKstatus (Tstatus, Pstatus);
  2351.            if (Pstatus > CDF_WARN) {
  2352.              Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2353.                    CONFIRM_, CDF_DIMINDICES_, Cindices,
  2354.                    NULL_);
  2355.              CHECKstatus (Tstatus, Pstatus);
  2356.              if (Pstatus > CDF_WARN) {
  2357.            for (i = 0; i < numDims; i++) indices[i] = Cindices[i] + 1;
  2358.          }
  2359.            }
  2360.          }
  2361.          break;
  2362.        }
  2363.        case CDF_DIMCOUNTS_: {
  2364.          long *counts = va_arg (ap, long *);
  2365.          if (Pstatus > CDF_WARN) {
  2366.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2367.                  CONFIRM_, CDF_DIMCOUNTS_, counts,
  2368.                  NULL_);
  2369.            CHECKstatus (Tstatus, Pstatus);
  2370.          }
  2371.          break;
  2372.        }
  2373.        case CDF_DIMINTERVALS_: {
  2374.          long *intervals = va_arg (ap, long *);
  2375.          if (Pstatus > CDF_WARN) {
  2376.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2377.                  CONFIRM_, CDF_DIMINTERVALS_, intervals,
  2378.                  NULL_);
  2379.            CHECKstatus (Tstatus, Pstatus);
  2380.          }
  2381.          break;
  2382.        }
  2383.        case VAR_SEQPOS_: {
  2384.          long numDims;
  2385.          long Cindices[CDF_MAX_DIMS];
  2386.          long recNum;
  2387.          long i;
  2388.          long *rec_num = va_arg (ap, long *);
  2389.          long *indices = va_arg (ap, long *);
  2390.          if (Pstatus > CDF_WARN) {
  2391.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2392.                  GET_, CDF_NUMDIMS_, &numDims,
  2393.                  NULL_);
  2394.            CHECKstatus (Tstatus, Pstatus);
  2395.            if (Pstatus > CDF_WARN) {
  2396.              Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2397.                    CONFIRM_, VAR_SEQPOS_, &recNum,
  2398.                                    Cindices,
  2399.                    NULL_);
  2400.              CHECKstatus (Tstatus, Pstatus);
  2401.              if (Pstatus > CDF_WARN) {
  2402.            *rec_num = recNum + 1;
  2403.            for (i = 0; i < numDims; i++) indices[i] = Cindices[i] + 1;
  2404.          }
  2405.            }
  2406.          }
  2407.          break;
  2408.        }
  2409.        case ATTR_: {
  2410.          long attrNum;
  2411.          long *attr_num = va_arg (ap, long *);
  2412.          if (Pstatus > CDF_WARN) {
  2413.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2414.                  CONFIRM_, ATTR_, &attrNum,
  2415.                  NULL_);
  2416.            CHECKstatus (Tstatus, Pstatus);
  2417.            if (Pstatus > CDF_WARN) *attr_num = attrNum + 1;
  2418.          }
  2419.          break;
  2420.        }
  2421.        case ENTRY_: {
  2422.          long entryNum;
  2423.          long *entry_num = va_arg (ap, long *);
  2424.          if (Pstatus > CDF_WARN) {
  2425.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2426.                  CONFIRM_, ENTRY_, &entryNum,
  2427.                  NULL_);
  2428.            CHECKstatus (Tstatus, Pstatus);
  2429.            if (Pstatus > CDF_WARN) *entry_num = entryNum + 1;
  2430.          }
  2431.          break;
  2432.        }
  2433.        default: {
  2434.          fnc = item;
  2435.          break;
  2436.        }
  2437.      }
  2438.      if (fnc == item) break;
  2439.       }
  2440.       break;
  2441.  
  2442.     case GET_:
  2443.       for (;;) {
  2444.          item = *(va_arg (ap, long *));
  2445.             switch (item) {
  2446.        case CDF_NUMDIMS_: {
  2447.          long *numDims = va_arg (ap, long *);
  2448.          if (Pstatus > CDF_WARN) {
  2449.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2450.                  GET_, CDF_NUMDIMS_, numDims,
  2451.                  NULL_);
  2452.            CHECKstatus (Tstatus, Pstatus);
  2453.          }
  2454.          break;
  2455.        }
  2456.        case CDF_DIMSIZES_: {
  2457.          long *dimsize = va_arg (ap, long *);
  2458.          if (Pstatus > CDF_WARN) {
  2459.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2460.                  GET_, CDF_DIMSIZES_, dimsize,
  2461.                  NULL_);
  2462.            CHECKstatus (Tstatus, Pstatus);
  2463.          }
  2464.          break;
  2465.        }
  2466.        case CDF_ENCODING_: {
  2467.          long *encoding = va_arg (ap, long *);
  2468.          if (Pstatus > CDF_WARN) {
  2469.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2470.                  GET_, CDF_ENCODING_, encoding,
  2471.                  NULL_);
  2472.            CHECKstatus (Tstatus, Pstatus);
  2473.          }
  2474.          break;
  2475.        }
  2476.        case CDF_MAJORITY_: {
  2477.          long *majority = va_arg (ap, long *);
  2478.          if (Pstatus > CDF_WARN) {
  2479.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2480.                  GET_, CDF_MAJORITY_, majority,
  2481.                  NULL_);
  2482.            CHECKstatus (Tstatus, Pstatus);
  2483.          }
  2484.          break;
  2485.        }
  2486.        case CDF_FORMAT_: {
  2487.          long *format = va_arg (ap, long *);
  2488.          if (Pstatus > CDF_WARN) {
  2489.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2490.                  GET_, CDF_FORMAT_, format,
  2491.                  NULL_);
  2492.            CHECKstatus (Tstatus, Pstatus);
  2493.          }
  2494.          break;
  2495.        }
  2496.        case CDF_COPYRIGHT_: {
  2497.          char text[CDF_DOCUMENT_LEN+1];
  2498.          char *copyRight = va_arg (ap, char *);
  2499.          if (Pstatus > CDF_WARN) {
  2500.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2501.                  GET_, CDF_COPYRIGHT_, text,
  2502.                  NULL_);
  2503.            CHECKstatus (Tstatus, Pstatus);
  2504.            if (Pstatus > CDF_WARN) {
  2505.          CtoFORTstring (text, copyRight,
  2506.                 stringLengths[stringCount]);
  2507.          stringCount++;
  2508.            }
  2509.          }
  2510.          break;
  2511.        }
  2512.        case LIB_COPYRIGHT_: {
  2513.          char text[CDF_DOCUMENT_LEN+1];
  2514.          char *copyRight = va_arg (ap, char *);
  2515.          if (Pstatus > CDF_WARN) {
  2516.            Tstatus = CDFlib (GET_, LIB_COPYRIGHT_, text,
  2517.                  NULL_);
  2518.            CHECKstatus (Tstatus, Pstatus);
  2519.            if (Pstatus > CDF_WARN) {
  2520.          CtoFORTstring (text, copyRight,
  2521.                 stringLengths[stringCount]);
  2522.          stringCount++;
  2523.            }
  2524.          }
  2525.          break;
  2526.        }
  2527.        case CDF_NUMVARS_: {
  2528.          long *numvars = va_arg (ap, long *);
  2529.          if (Pstatus > CDF_WARN) {
  2530.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2531.                  GET_, CDF_NUMVARS_, numvars,
  2532.                  NULL_);
  2533.            CHECKstatus (Tstatus, Pstatus);
  2534.          }
  2535.          break;
  2536.        }
  2537.        case CDF_NUMATTRS_: {
  2538.          long *numattr = va_arg (ap, long *);
  2539.          if (Pstatus > CDF_WARN) {
  2540.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2541.                  GET_, CDF_NUMATTRS_, numattr,
  2542.                  NULL_);
  2543.            CHECKstatus (Tstatus, Pstatus);
  2544.          }
  2545.          break;
  2546.        }
  2547.        case CDF_MAXREC_: {
  2548.          long maxRec;
  2549.          long *max_rec = va_arg (ap, long *);
  2550.          if (Pstatus > CDF_WARN) {
  2551.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2552.                  GET_, CDF_MAXREC_, &maxRec,
  2553.                  NULL_);
  2554.            CHECKstatus (Tstatus, Pstatus);
  2555.            if (Pstatus > CDF_WARN) *max_rec = maxRec + 1;
  2556.          }
  2557.          break;
  2558.        }
  2559.        case CDF_VERSION_: {
  2560.          long *version = va_arg (ap, long *);
  2561.          if (Pstatus > CDF_WARN) {
  2562.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2563.                  GET_, CDF_VERSION_, version,
  2564.                  NULL_);
  2565.            CHECKstatus (Tstatus, Pstatus);
  2566.          }
  2567.          break;
  2568.        }
  2569.        case CDF_RELEASE_: {
  2570.          long *release = va_arg (ap, long *);
  2571.          if (Pstatus > CDF_WARN) {
  2572.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2573.                  GET_, CDF_RELEASE_, release,
  2574.                  NULL_);
  2575.            CHECKstatus (Tstatus, Pstatus);
  2576.          }
  2577.          break;
  2578.        }
  2579.        case CDF_INCREMENT_: {
  2580.          long *increment = va_arg (ap, long *);
  2581.          if (Pstatus > CDF_WARN) {
  2582.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2583.                  GET_, CDF_INCREMENT_, increment,
  2584.                  NULL_);
  2585.            CHECKstatus (Tstatus, Pstatus);
  2586.          }
  2587.          break;
  2588.        }
  2589.        case LIB_VERSION_: {
  2590.          long *version = va_arg (ap, long *);
  2591.          if (Pstatus > CDF_WARN) {
  2592.            Tstatus = CDFlib (GET_, LIB_VERSION_, version,
  2593.                  NULL_);
  2594.            CHECKstatus (Tstatus, Pstatus);
  2595.          }
  2596.          break;
  2597.        }
  2598.        case LIB_RELEASE_: {
  2599.          long *release = va_arg (ap, long *);
  2600.          if (Pstatus > CDF_WARN) {
  2601.            Tstatus = CDFlib (GET_, LIB_RELEASE_, release,
  2602.                  NULL_);
  2603.            CHECKstatus (Tstatus, Pstatus);
  2604.          }
  2605.          break;
  2606.        }
  2607.        case LIB_INCREMENT_: {
  2608.          long *increment = va_arg (ap, long *);
  2609.          if (Pstatus > CDF_WARN) {
  2610.            Tstatus = CDFlib (GET_, LIB_INCREMENT_, increment,
  2611.                  NULL_);
  2612.            CHECKstatus (Tstatus, Pstatus);
  2613.          }
  2614.          break;
  2615.        }
  2616.        case LIB_subINCREMENT_: {
  2617.          char subIncr;
  2618.          char *subincrement = va_arg (ap, char *);
  2619.          if (Pstatus > CDF_WARN) {
  2620.            Tstatus = CDFlib (GET_, LIB_subINCREMENT_, &subIncr,
  2621.                  NULL_);
  2622.            CHECKstatus (Tstatus, Pstatus);
  2623.            if (Pstatus > CDF_WARN) {
  2624.          CtoFORTstring (&subIncr, subincrement, 1);
  2625.          stringCount++;
  2626.            }
  2627.          }
  2628.          break;
  2629.        }
  2630.        case VAR_NAME_: {
  2631.          char varName[CDF_VAR_NAME_LEN+1];
  2632.          char *name = va_arg (ap, char *);
  2633.          if (Pstatus > CDF_WARN) {
  2634.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2635.                  GET_, VAR_NAME_, varName,
  2636.                  NULL_);
  2637.            CHECKstatus (Tstatus, Pstatus);
  2638.            if (Pstatus > CDF_WARN) {
  2639.          CtoFORTstring (varName, name,
  2640.                 stringLengths[stringCount]);
  2641.          stringCount++;
  2642.            }
  2643.          }
  2644.          break;
  2645.        }
  2646.        case VAR_DATATYPE_: {
  2647.          long *datatype = va_arg (ap, long *);
  2648.          if (Pstatus > CDF_WARN) {
  2649.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2650.                  GET_, VAR_DATATYPE_, datatype,
  2651.                  NULL_);
  2652.            CHECKstatus (Tstatus, Pstatus);
  2653.          }
  2654.          break;
  2655.        }
  2656.        case VAR_NUMELEMS_: {
  2657.          long *numElements = va_arg (ap, long *);
  2658.          if (Pstatus > CDF_WARN) {
  2659.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2660.                  GET_, VAR_NUMELEMS_, numElements,
  2661.                  NULL_);
  2662.            CHECKstatus (Tstatus, Pstatus);
  2663.          }
  2664.          break;
  2665.        }
  2666.        case VAR_RECVARY_: {
  2667.          long *recvary = va_arg (ap, long *);
  2668.          if (Pstatus > CDF_WARN) {
  2669.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2670.                  GET_, VAR_RECVARY_, recvary,
  2671.                  NULL_);
  2672.            CHECKstatus (Tstatus, Pstatus);
  2673.          }
  2674.          break;
  2675.        }
  2676.        case VAR_DIMVARYS_: {
  2677.          long *dimVarys = va_arg (ap, long *);
  2678.          if (Pstatus > CDF_WARN) {
  2679.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2680.                  GET_, VAR_DIMVARYS_, dimVarys,
  2681.                  NULL_);
  2682.            CHECKstatus (Tstatus, Pstatus);
  2683.          }
  2684.          break;
  2685.        }
  2686.        case VAR_MAXREC_: {
  2687.          long varMaxRec;
  2688.          long *var_max_rec = va_arg (ap, long *);
  2689.          if (Pstatus > CDF_WARN) {
  2690.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2691.                  GET_, VAR_MAXREC_, &varMaxRec,
  2692.                  NULL_);
  2693.            CHECKstatus (Tstatus, Pstatus);
  2694.            if (Pstatus > CDF_WARN) *var_max_rec = varMaxRec + 1;
  2695.          }
  2696.          break;
  2697.        }
  2698.        case VAR_NUMBER_: {
  2699.          long varNum;
  2700.          char *name = va_arg (ap, char *);
  2701.          long *varnum = va_arg (ap, long *);
  2702.          if (Pstatus > CDF_WARN) {
  2703.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2704.                  GET_, VAR_NUMBER_,
  2705.                        NULterminate
  2706.                          (name,
  2707.                           stringLengths[stringCount]),
  2708.                        &varNum,
  2709.                  NULL_);
  2710.            CHECKstatus (Tstatus, Pstatus);
  2711.            if (Pstatus > CDF_WARN) {
  2712.          *varnum = varNum + 1;
  2713.          stringCount++;
  2714.            }
  2715.          }
  2716.          break;
  2717.        }
  2718.        case VAR_EXTENDRECS_: {
  2719.          long *NextendRecs = va_arg (ap, long *);
  2720.          if (Pstatus > CDF_WARN) {
  2721.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2722.                  GET_, VAR_EXTENDRECS_, NextendRecs,
  2723.                  NULL_);
  2724.            CHECKstatus (Tstatus, Pstatus);
  2725.          }
  2726.          break;
  2727.        }
  2728.        case VAR_FILLVALUE_: {
  2729.          long dataType;
  2730.          void *fillValue = va_arg (ap, void *);
  2731.          if (Pstatus > CDF_WARN) {
  2732.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2733.                  GET_, VAR_DATATYPE_, &dataType,
  2734.                        VAR_DATA_, fillValue,
  2735.                  NULL_);
  2736.            CHECKstatus (Tstatus, Pstatus);
  2737.            if (Pstatus > CDF_WARN)
  2738.              if (STRINGdataType(dataType)) stringCount++;
  2739.          }
  2740.          break;
  2741.        }
  2742.        case VAR_DATA_: {
  2743.          long dataType;
  2744.          void *value = va_arg (ap, void *);
  2745.          if (Pstatus > CDF_WARN) {
  2746.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2747.                  GET_, VAR_DATATYPE_, &dataType,
  2748.                        VAR_DATA_, value,
  2749.                  NULL_);
  2750.            CHECKstatus (Tstatus, Pstatus);
  2751.            if (Pstatus > CDF_WARN)
  2752.              if (STRINGdataType(dataType)) stringCount++;
  2753.          }
  2754.          break;
  2755.        }
  2756.        case VAR_HYPERDATA_: {
  2757.          long dataType;
  2758.          void *buffer = va_arg (ap, void *);
  2759.          if (Pstatus > CDF_WARN) {
  2760.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2761.                  GET_, VAR_DATATYPE_, &dataType,
  2762.                        VAR_HYPERDATA_, buffer,
  2763.                  NULL_);
  2764.            CHECKstatus (Tstatus, Pstatus);
  2765.            if (Pstatus > CDF_WARN)
  2766.              if (STRINGdataType(dataType)) stringCount++;
  2767.          }
  2768.          break;
  2769.        }
  2770.        case VAR_SEQDATA_: {
  2771.          long dataType;
  2772.          void *value = va_arg (ap, void *);
  2773.          if (Pstatus > CDF_WARN) {
  2774.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2775.                  GET_, VAR_DATATYPE_, &dataType,
  2776.                        VAR_SEQDATA_, value,
  2777.                  NULL_);
  2778.            CHECKstatus (Tstatus, Pstatus);
  2779.            if (Pstatus > CDF_WARN)
  2780.              if (STRINGdataType(dataType)) stringCount++;
  2781.          }
  2782.          break;
  2783.        }
  2784.        case ATTR_SCOPE_: {
  2785.          long *scope = va_arg (ap, long *);
  2786.          if (Pstatus > CDF_WARN) {
  2787.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2788.                  GET_, ATTR_SCOPE_, scope,
  2789.                  NULL_);
  2790.            CHECKstatus (Tstatus, Pstatus);
  2791.          }
  2792.          break;
  2793.        }
  2794.        case ATTR_NAME_: {
  2795.          char name[CDF_ATTR_NAME_LEN+1];
  2796.          char *attrname = va_arg (ap, char *);
  2797.          if (Pstatus > CDF_WARN) {
  2798.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2799.                  GET_, ATTR_NAME_, name,
  2800.                  NULL_);
  2801.            CHECKstatus (Tstatus, Pstatus);
  2802.            if (Pstatus > CDF_WARN) {
  2803.          CtoFORTstring (name, attrname,
  2804.                 stringLengths[stringCount]);
  2805.          stringCount++;
  2806.            }
  2807.          }
  2808.          break;
  2809.        }
  2810.        case ATTR_NUMBER_: {
  2811.          long attrNum;
  2812.          char *name = va_arg (ap, char *);
  2813.          long *attrnum = va_arg (ap, long *);
  2814.          if (Pstatus > CDF_WARN) {
  2815.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2816.                  GET_, ATTR_NUMBER_,
  2817.                        NULterminate
  2818.                          (name,
  2819.                           stringLengths[stringCount]),
  2820.                        &attrNum,
  2821.                  NULL_);
  2822.            CHECKstatus (Tstatus, Pstatus);
  2823.            if (Pstatus > CDF_WARN) {
  2824.          *attrnum = attrNum + 1;
  2825.          stringCount++;
  2826.            }
  2827.          }
  2828.          break;
  2829.        }
  2830.        case ATTR_MAXENTRY_: {
  2831.          long maxEntry;
  2832.          long *max_entry = va_arg (ap, long *);
  2833.          if (Pstatus > CDF_WARN) {
  2834.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2835.                  GET_, ATTR_MAXENTRY_, &maxEntry,
  2836.                  NULL_);
  2837.            CHECKstatus (Tstatus, Pstatus);
  2838.            if (Pstatus > CDF_WARN) *max_entry = maxEntry + 1;
  2839.          }
  2840.          break;
  2841.        }
  2842.        case ATTR_NUMENTRIES_: {
  2843.          long *numEntries = va_arg (ap, long *);
  2844.          if (Pstatus > CDF_WARN) {
  2845.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2846.                  GET_, ATTR_NUMENTRIES_, numEntries,
  2847.                  NULL_);
  2848.            CHECKstatus (Tstatus, Pstatus);
  2849.          }
  2850.          break;
  2851.        }
  2852.        case ENTRY_DATATYPE_: {
  2853.          long *datatype = va_arg (ap, long *);
  2854.          if (Pstatus > CDF_WARN) {
  2855.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2856.                  GET_, ENTRY_DATATYPE_, datatype,
  2857.                  NULL_);
  2858.            CHECKstatus (Tstatus, Pstatus);
  2859.          }
  2860.          break;
  2861.        }
  2862.        case ENTRY_NUMELEMS_: {
  2863.          long *numelem = va_arg (ap, long *);
  2864.          if (Pstatus > CDF_WARN) {
  2865.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2866.                  GET_, ENTRY_NUMELEMS_, numelem,
  2867.                  NULL_);
  2868.            CHECKstatus (Tstatus, Pstatus);
  2869.          }
  2870.          break;
  2871.        }
  2872.        case ENTRY_DATA_: {
  2873.          long dataType;
  2874.          void *value = va_arg (ap, void *);
  2875.          if (Pstatus > CDF_WARN) {
  2876.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2877.                  GET_, ENTRY_DATATYPE_, &dataType,
  2878.                        ENTRY_DATA_, value,
  2879.                  NULL_);
  2880.            CHECKstatus (Tstatus, Pstatus);
  2881.            if (Pstatus > CDF_WARN)
  2882.          if (STRINGdataType(dataType)) stringCount++;
  2883.          }
  2884.          break;
  2885.        }
  2886.        case STATUS_TEXT_: {
  2887.          char text[CDF_STATUSTEXT_LEN+1];
  2888.          char *textPtr = va_arg (ap, char *);
  2889.          if (Pstatus > CDF_WARN) {
  2890.            Tstatus = CDFlib (SELECT_, CDF_STATUS_, CURstatus,
  2891.                  GET_, STATUS_TEXT_, text,
  2892.                  NULL_);
  2893.            CHECKstatus (Tstatus, Pstatus);
  2894.            if (Pstatus > CDF_WARN) {
  2895.          CtoFORTstring (text, textPtr,
  2896.                 stringLengths[stringCount]);
  2897.          stringCount++;
  2898.            }
  2899.          }
  2900.          break;
  2901.        }
  2902.        default: {
  2903.          fnc = item;
  2904.          break;
  2905.        }
  2906.      }
  2907.      if (fnc == item) break;
  2908.       }
  2909.       break;
  2910.  
  2911.     case PUT_:
  2912.       for (;;) {
  2913.          item = *(va_arg (ap, long *));
  2914.             switch (item) {
  2915.        case CDF_ARRAY_: {
  2916.          long *numDims = va_arg (ap, long *);
  2917.          long *dimSizes = va_arg (ap, long *);
  2918.          if (Pstatus > CDF_WARN) {
  2919.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2920.                  PUT_, CDF_ARRAY_, *numDims, dimSizes,
  2921.                  NULL_);
  2922.            CHECKstatus (Tstatus, Pstatus);
  2923.          }
  2924.          break;
  2925.        }
  2926.        case CDF_ENCODING_: {
  2927.          long *encoding = va_arg (ap, long *);
  2928.          if (Pstatus > CDF_WARN) {
  2929.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2930.                  PUT_, CDF_ENCODING_, *encoding,
  2931.                  NULL_);
  2932.            CHECKstatus (Tstatus, Pstatus);
  2933.          }
  2934.          break;
  2935.        }
  2936.        case CDF_MAJORITY_: {
  2937.          long *majority = va_arg (ap, long *);
  2938.          if (Pstatus > CDF_WARN) {
  2939.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2940.                  PUT_, CDF_MAJORITY_, *majority,
  2941.                  NULL_);
  2942.            CHECKstatus (Tstatus, Pstatus);
  2943.          }
  2944.          break;
  2945.        }
  2946.        case CDF_FORMAT_: {
  2947.          long *format = va_arg (ap, long *);
  2948.          if (Pstatus > CDF_WARN) {
  2949.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2950.                  PUT_, CDF_FORMAT_, *format,
  2951.                  NULL_);
  2952.            CHECKstatus (Tstatus, Pstatus);
  2953.          }
  2954.          break;
  2955.        }
  2956.        case VAR_NAME_: {
  2957.          char *varName = va_arg (ap, char *);
  2958.          if (Pstatus > CDF_WARN) {
  2959.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2960.                  PUT_, VAR_NAME_,
  2961.                        NULterminate
  2962.                          (varName,
  2963.                           stringLengths[stringCount]),
  2964.                  NULL_);
  2965.            CHECKstatus (Tstatus, Pstatus);
  2966.            if (Pstatus > CDF_WARN) stringCount++;
  2967.          }
  2968.          break;
  2969.        }
  2970.        case VAR_DATASPEC_: {
  2971.          long *dataType = va_arg (ap, long *);
  2972.          long *numElements = va_arg (ap, long *);
  2973.          if (Pstatus > CDF_WARN) {
  2974.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2975.                  PUT_, VAR_DATASPEC_, *dataType,
  2976.                              *numElements,
  2977.                  NULL_);
  2978.            CHECKstatus (Tstatus, Pstatus);
  2979.          }
  2980.          break;
  2981.        }
  2982.        case VAR_RECVARY_: {
  2983.          long *recVariance = va_arg (ap, long *);
  2984.          if (Pstatus > CDF_WARN) {
  2985.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2986.                  PUT_, VAR_RECVARY_, *recVariance,
  2987.                  NULL_);
  2988.            CHECKstatus (Tstatus, Pstatus);
  2989.          }
  2990.          break;
  2991.        }
  2992.        case VAR_DIMVARYS_: {
  2993.          long *dimVarys = va_arg (ap, long *);
  2994.          if (Pstatus > CDF_WARN) {
  2995.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  2996.                  PUT_, VAR_DIMVARYS_, dimVarys,
  2997.                  NULL_);
  2998.            CHECKstatus (Tstatus, Pstatus);
  2999.          }
  3000.          break;
  3001.        }
  3002.        case VAR_INITIALRECS_: {
  3003.          long *NinitialRecs = va_arg (ap, long *);
  3004.          if (Pstatus > CDF_WARN) {
  3005.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  3006.                  PUT_, VAR_INITIALRECS_, *NinitialRecs,
  3007.                  NULL_);
  3008.            CHECKstatus (Tstatus, Pstatus);
  3009.          }
  3010.          break;
  3011.        }
  3012.        case VAR_EXTENDRECS_: {
  3013.          long *NextendRecs = va_arg (ap, long *);
  3014.          if (Pstatus > CDF_WARN) {
  3015.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  3016.                  PUT_, VAR_EXTENDRECS_, *NextendRecs,
  3017.                  NULL_);
  3018.            CHECKstatus (Tstatus, Pstatus);
  3019.          }
  3020.          break;
  3021.        }
  3022.        case VAR_FILLVALUE_: {
  3023.          long dataType;
  3024.          void *value = va_arg (ap, void *);
  3025.          if (Pstatus > CDF_WARN) {
  3026.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  3027.                  GET_, VAR_DATATYPE_, &dataType,
  3028.                  PUT_, VAR_FILLVALUE_, value,
  3029.                  NULL_);
  3030.            CHECKstatus (Tstatus, Pstatus);
  3031.            if (Pstatus > CDF_WARN)
  3032.          if (STRINGdataType(dataType)) stringCount++;
  3033.          }
  3034.          break;
  3035.        }
  3036.        case VAR_DATA_: {
  3037.          long dataType;
  3038.          void *value = va_arg (ap, void *);
  3039.          if (Pstatus > CDF_WARN) {
  3040.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  3041.                  GET_, VAR_DATATYPE_, &dataType,
  3042.                  PUT_, VAR_DATA_, value,
  3043.                  NULL_);
  3044.            CHECKstatus (Tstatus, Pstatus);
  3045.            if (Pstatus > CDF_WARN)
  3046.              if (STRINGdataType(dataType)) stringCount++;
  3047.          }
  3048.          break;
  3049.        }
  3050.        case VAR_HYPERDATA_: {
  3051.          long dataType;
  3052.          void *buffer = va_arg (ap, void *);
  3053.          if (Pstatus > CDF_WARN) {
  3054.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  3055.                  GET_, VAR_DATATYPE_, &dataType,
  3056.                  PUT_, VAR_HYPERDATA_, buffer,
  3057.                  NULL_);
  3058.            CHECKstatus (Tstatus, Pstatus);
  3059.            if (Pstatus > CDF_WARN)
  3060.              if (STRINGdataType(dataType)) stringCount++;
  3061.          }
  3062.          break;
  3063.        }
  3064.        case VAR_SEQDATA_: {
  3065.          long dataType;
  3066.          void *value = va_arg (ap, void *);
  3067.          if (Pstatus > CDF_WARN) {
  3068.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  3069.                  GET_, VAR_DATATYPE_, &dataType,
  3070.                  PUT_, VAR_SEQDATA_, value,
  3071.                  NULL_);
  3072.            CHECKstatus (Tstatus, Pstatus);
  3073.            if (Pstatus > CDF_WARN)
  3074.              if (STRINGdataType(dataType)) stringCount++;
  3075.          }
  3076.          break;
  3077.        }
  3078.        case ATTR_SCOPE_: {
  3079.          long *scope = va_arg (ap, long *);
  3080.          if (Pstatus > CDF_WARN) {
  3081.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  3082.                  PUT_, ATTR_SCOPE_, *scope,
  3083.                  NULL_);
  3084.            CHECKstatus (Tstatus, Pstatus);
  3085.          }
  3086.          break;
  3087.        }
  3088.        case ATTR_NAME_: {
  3089.          char *attrname = va_arg (ap, char *);
  3090.          if (Pstatus > CDF_WARN) {
  3091.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  3092.                  PUT_, ATTR_NAME_,
  3093.                       NULterminate
  3094.                         (attrname,
  3095.                          stringLengths[stringCount]),
  3096.                  NULL_);
  3097.            CHECKstatus (Tstatus, Pstatus);
  3098.            if (Pstatus > CDF_WARN) stringCount++;
  3099.          }
  3100.          break;
  3101.        }
  3102.        case ENTRY_DATA_: {
  3103.          long *dataType = va_arg (ap, long *);
  3104.          long *numElements = va_arg (ap, long *);
  3105.          void *value = va_arg (ap, void *);
  3106.          if (Pstatus > CDF_WARN) {
  3107.            Tstatus = CDFlib (SELECT_, CDF_, CURid,
  3108.                  PUT_, ENTRY_DATA_, *dataType,
  3109.                                *numElements, value,
  3110.                  NULL_);
  3111.            CHECKstatus (Tstatus, Pstatus);
  3112.            if (Pstatus > CDF_WARN)
  3113.          if (STRINGdataType(*dataType)) stringCount++;
  3114.          }
  3115.          break;
  3116.        }
  3117.        default: {
  3118.          fnc = item;
  3119.          break;
  3120.        }
  3121.      }
  3122.      if (fnc == item) break;
  3123.       }
  3124.       break;
  3125.  
  3126.     default: {
  3127.       va_end (ap);
  3128.       if (stringLengths != NULL) free (stringLengths);
  3129.       return BAD_FNC_OR_ITEM;
  3130.     }
  3131.   }
  3132.  
  3133. va_end (ap);
  3134.  
  3135. if (stringLengths != NULL) free (stringLengths);
  3136.  
  3137. *status = Pstatus;
  3138. return Pstatus;
  3139. }
  3140. #endif
  3141.